rx-decode.c revision 1.1
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 984 "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 987 "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 990 "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 957 "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 957 "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 902 "rx-decode.opc" 4917 int b AU = op[0] & 0x01; 4918 #line 902 "rx-decode.opc" 4919 int ittt AU = (op[1] >> 4) & 0x0f; 4920 #line 902 "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 902 "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 914 "rx-decode.opc" 4958 int b AU = op[0] & 0x01; 4959 #line 914 "rx-decode.opc" 4960 int ittt AU = (op[1] >> 4) & 0x0f; 4961 #line 914 "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 914 "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 926 "rx-decode.opc" 4999 int b AU = op[0] & 0x01; 5000 #line 926 "rx-decode.opc" 5001 int ittt AU = (op[1] >> 4) & 0x0f; 5002 #line 926 "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 926 "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 963 "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 963 "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 960 "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 960 "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 978 "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 981 "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 993 "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 954 "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 954 "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 951 "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 951 "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 (sd == 3 && 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 906 "rx-decode.opc" 6822 int sd AU = op[0] & 0x03; 6823 #line 906 "rx-decode.opc" 6824 int rdst AU = (op[1] >> 4) & 0x0f; 6825 #line 906 "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 906 "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 918 "rx-decode.opc" 6890 int sd AU = op[0] & 0x03; 6891 #line 918 "rx-decode.opc" 6892 int rdst AU = (op[1] >> 4) & 0x0f; 6893 #line 918 "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 918 "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 if (sd == 3) /* bset reg,reg */ 7821 BWL(LSIZE); 7822 7823 } 7824 break; 7825 } 7826 break; 7827 case 0x61: 7828 GETBYTE (); 7829 switch (op[2] & 0x00) 7830 { 7831 case 0x00: 7832 goto op_semantics_57; 7833 break; 7834 } 7835 break; 7836 case 0x62: 7837 GETBYTE (); 7838 switch (op[2] & 0x00) 7839 { 7840 case 0x00: 7841 goto op_semantics_57; 7842 break; 7843 } 7844 break; 7845 case 0x63: 7846 GETBYTE (); 7847 switch (op[2] & 0x00) 7848 { 7849 case 0x00: 7850 goto op_semantics_57; 7851 break; 7852 } 7853 break; 7854 case 0x64: 7855 GETBYTE (); 7856 switch (op[2] & 0x00) 7857 { 7858 case 0x00: 7859 op_semantics_58: 7860 { 7861 /** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */ 7862 #line 909 "rx-decode.opc" 7863 int sd AU = op[1] & 0x03; 7864 #line 909 "rx-decode.opc" 7865 int rdst AU = (op[2] >> 4) & 0x0f; 7866 #line 909 "rx-decode.opc" 7867 int rsrc AU = op[2] & 0x0f; 7868 if (trace) 7869 { 7870 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7871 "/** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */", 7872 op[0], op[1], op[2]); 7873 printf (" sd = 0x%x,", sd); 7874 printf (" rdst = 0x%x,", rdst); 7875 printf (" rsrc = 0x%x\n", rsrc); 7876 } 7877 SYNTAX("bclr %1, %0%S0"); 7878 #line 909 "rx-decode.opc" 7879 ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____; 7880 if (sd == 3) /* bset reg,reg */ 7881 BWL(LSIZE); 7882 7883 } 7884 break; 7885 } 7886 break; 7887 case 0x65: 7888 GETBYTE (); 7889 switch (op[2] & 0x00) 7890 { 7891 case 0x00: 7892 goto op_semantics_58; 7893 break; 7894 } 7895 break; 7896 case 0x66: 7897 GETBYTE (); 7898 switch (op[2] & 0x00) 7899 { 7900 case 0x00: 7901 goto op_semantics_58; 7902 break; 7903 } 7904 break; 7905 case 0x67: 7906 GETBYTE (); 7907 switch (op[2] & 0x00) 7908 { 7909 case 0x00: 7910 goto op_semantics_58; 7911 break; 7912 } 7913 break; 7914 case 0x68: 7915 GETBYTE (); 7916 switch (op[2] & 0x00) 7917 { 7918 case 0x00: 7919 op_semantics_59: 7920 { 7921 /** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */ 7922 #line 921 "rx-decode.opc" 7923 int sd AU = op[1] & 0x03; 7924 #line 921 "rx-decode.opc" 7925 int rdst AU = (op[2] >> 4) & 0x0f; 7926 #line 921 "rx-decode.opc" 7927 int rsrc AU = op[2] & 0x0f; 7928 if (trace) 7929 { 7930 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7931 "/** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */", 7932 op[0], op[1], op[2]); 7933 printf (" sd = 0x%x,", sd); 7934 printf (" rdst = 0x%x,", rdst); 7935 printf (" rsrc = 0x%x\n", rsrc); 7936 } 7937 SYNTAX("btst %2, %1%S1"); 7938 #line 921 "rx-decode.opc" 7939 ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ZC; 7940 if (sd == 3) /* bset reg,reg */ 7941 BWL(LSIZE); 7942 7943 } 7944 break; 7945 } 7946 break; 7947 case 0x69: 7948 GETBYTE (); 7949 switch (op[2] & 0x00) 7950 { 7951 case 0x00: 7952 goto op_semantics_59; 7953 break; 7954 } 7955 break; 7956 case 0x6a: 7957 GETBYTE (); 7958 switch (op[2] & 0x00) 7959 { 7960 case 0x00: 7961 goto op_semantics_59; 7962 break; 7963 } 7964 break; 7965 case 0x6b: 7966 GETBYTE (); 7967 switch (op[2] & 0x00) 7968 { 7969 case 0x00: 7970 goto op_semantics_59; 7971 break; 7972 } 7973 break; 7974 case 0x6c: 7975 GETBYTE (); 7976 switch (op[2] & 0x00) 7977 { 7978 case 0x00: 7979 op_semantics_60: 7980 { 7981 /** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */ 7982 #line 933 "rx-decode.opc" 7983 int sd AU = op[1] & 0x03; 7984 #line 933 "rx-decode.opc" 7985 int rdst AU = (op[2] >> 4) & 0x0f; 7986 #line 933 "rx-decode.opc" 7987 int rsrc AU = op[2] & 0x0f; 7988 if (trace) 7989 { 7990 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7991 "/** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */", 7992 op[0], op[1], op[2]); 7993 printf (" sd = 0x%x,", sd); 7994 printf (" rdst = 0x%x,", rdst); 7995 printf (" rsrc = 0x%x\n", rsrc); 7996 } 7997 SYNTAX("bnot %1, %0%S0"); 7998 #line 933 "rx-decode.opc" 7999 ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); 8000 if (sd == 3) /* bset reg,reg */ 8001 BWL(LSIZE); 8002 8003 } 8004 break; 8005 } 8006 break; 8007 case 0x6d: 8008 GETBYTE (); 8009 switch (op[2] & 0x00) 8010 { 8011 case 0x00: 8012 goto op_semantics_60; 8013 break; 8014 } 8015 break; 8016 case 0x6e: 8017 GETBYTE (); 8018 switch (op[2] & 0x00) 8019 { 8020 case 0x00: 8021 goto op_semantics_60; 8022 break; 8023 } 8024 break; 8025 case 0x6f: 8026 GETBYTE (); 8027 switch (op[2] & 0x00) 8028 { 8029 case 0x00: 8030 goto op_semantics_60; 8031 break; 8032 } 8033 break; 8034 case 0x80: 8035 GETBYTE (); 8036 switch (op[2] & 0x00) 8037 { 8038 case 0x00: 8039 op_semantics_61: 8040 { 8041 /** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */ 8042 #line 864 "rx-decode.opc" 8043 int sd AU = op[1] & 0x03; 8044 #line 864 "rx-decode.opc" 8045 int rsrc AU = (op[2] >> 4) & 0x0f; 8046 #line 864 "rx-decode.opc" 8047 int rdst AU = op[2] & 0x0f; 8048 if (trace) 8049 { 8050 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8051 "/** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */", 8052 op[0], op[1], op[2]); 8053 printf (" sd = 0x%x,", sd); 8054 printf (" rsrc = 0x%x,", rsrc); 8055 printf (" rdst = 0x%x\n", rdst); 8056 } 8057 SYNTAX("fsub %1%S1, %0"); 8058 #line 864 "rx-decode.opc" 8059 ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8060 8061 } 8062 break; 8063 } 8064 break; 8065 case 0x81: 8066 GETBYTE (); 8067 switch (op[2] & 0x00) 8068 { 8069 case 0x00: 8070 goto op_semantics_61; 8071 break; 8072 } 8073 break; 8074 case 0x82: 8075 GETBYTE (); 8076 switch (op[2] & 0x00) 8077 { 8078 case 0x00: 8079 goto op_semantics_61; 8080 break; 8081 } 8082 break; 8083 case 0x83: 8084 GETBYTE (); 8085 switch (op[2] & 0x00) 8086 { 8087 case 0x00: 8088 goto op_semantics_61; 8089 break; 8090 } 8091 break; 8092 case 0x84: 8093 GETBYTE (); 8094 switch (op[2] & 0x00) 8095 { 8096 case 0x00: 8097 op_semantics_62: 8098 { 8099 /** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */ 8100 #line 858 "rx-decode.opc" 8101 int sd AU = op[1] & 0x03; 8102 #line 858 "rx-decode.opc" 8103 int rsrc AU = (op[2] >> 4) & 0x0f; 8104 #line 858 "rx-decode.opc" 8105 int rdst AU = op[2] & 0x0f; 8106 if (trace) 8107 { 8108 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8109 "/** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */", 8110 op[0], op[1], op[2]); 8111 printf (" sd = 0x%x,", sd); 8112 printf (" rsrc = 0x%x,", rsrc); 8113 printf (" rdst = 0x%x\n", rdst); 8114 } 8115 SYNTAX("fcmp %1%S1, %0"); 8116 #line 858 "rx-decode.opc" 8117 ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F_OSZ_; 8118 8119 } 8120 break; 8121 } 8122 break; 8123 case 0x85: 8124 GETBYTE (); 8125 switch (op[2] & 0x00) 8126 { 8127 case 0x00: 8128 goto op_semantics_62; 8129 break; 8130 } 8131 break; 8132 case 0x86: 8133 GETBYTE (); 8134 switch (op[2] & 0x00) 8135 { 8136 case 0x00: 8137 goto op_semantics_62; 8138 break; 8139 } 8140 break; 8141 case 0x87: 8142 GETBYTE (); 8143 switch (op[2] & 0x00) 8144 { 8145 case 0x00: 8146 goto op_semantics_62; 8147 break; 8148 } 8149 break; 8150 case 0x88: 8151 GETBYTE (); 8152 switch (op[2] & 0x00) 8153 { 8154 case 0x00: 8155 op_semantics_63: 8156 { 8157 /** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */ 8158 #line 852 "rx-decode.opc" 8159 int sd AU = op[1] & 0x03; 8160 #line 852 "rx-decode.opc" 8161 int rsrc AU = (op[2] >> 4) & 0x0f; 8162 #line 852 "rx-decode.opc" 8163 int rdst AU = op[2] & 0x0f; 8164 if (trace) 8165 { 8166 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8167 "/** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */", 8168 op[0], op[1], op[2]); 8169 printf (" sd = 0x%x,", sd); 8170 printf (" rsrc = 0x%x,", rsrc); 8171 printf (" rdst = 0x%x\n", rdst); 8172 } 8173 SYNTAX("fadd %1%S1, %0"); 8174 #line 852 "rx-decode.opc" 8175 ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8176 8177 } 8178 break; 8179 } 8180 break; 8181 case 0x89: 8182 GETBYTE (); 8183 switch (op[2] & 0x00) 8184 { 8185 case 0x00: 8186 goto op_semantics_63; 8187 break; 8188 } 8189 break; 8190 case 0x8a: 8191 GETBYTE (); 8192 switch (op[2] & 0x00) 8193 { 8194 case 0x00: 8195 goto op_semantics_63; 8196 break; 8197 } 8198 break; 8199 case 0x8b: 8200 GETBYTE (); 8201 switch (op[2] & 0x00) 8202 { 8203 case 0x00: 8204 goto op_semantics_63; 8205 break; 8206 } 8207 break; 8208 case 0x8c: 8209 GETBYTE (); 8210 switch (op[2] & 0x00) 8211 { 8212 case 0x00: 8213 op_semantics_64: 8214 { 8215 /** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */ 8216 #line 873 "rx-decode.opc" 8217 int sd AU = op[1] & 0x03; 8218 #line 873 "rx-decode.opc" 8219 int rsrc AU = (op[2] >> 4) & 0x0f; 8220 #line 873 "rx-decode.opc" 8221 int rdst AU = op[2] & 0x0f; 8222 if (trace) 8223 { 8224 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8225 "/** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */", 8226 op[0], op[1], op[2]); 8227 printf (" sd = 0x%x,", sd); 8228 printf (" rsrc = 0x%x,", rsrc); 8229 printf (" rdst = 0x%x\n", rdst); 8230 } 8231 SYNTAX("fmul %1%S1, %0"); 8232 #line 873 "rx-decode.opc" 8233 ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8234 8235 } 8236 break; 8237 } 8238 break; 8239 case 0x8d: 8240 GETBYTE (); 8241 switch (op[2] & 0x00) 8242 { 8243 case 0x00: 8244 goto op_semantics_64; 8245 break; 8246 } 8247 break; 8248 case 0x8e: 8249 GETBYTE (); 8250 switch (op[2] & 0x00) 8251 { 8252 case 0x00: 8253 goto op_semantics_64; 8254 break; 8255 } 8256 break; 8257 case 0x8f: 8258 GETBYTE (); 8259 switch (op[2] & 0x00) 8260 { 8261 case 0x00: 8262 goto op_semantics_64; 8263 break; 8264 } 8265 break; 8266 case 0x90: 8267 GETBYTE (); 8268 switch (op[2] & 0x00) 8269 { 8270 case 0x00: 8271 op_semantics_65: 8272 { 8273 /** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */ 8274 #line 879 "rx-decode.opc" 8275 int sd AU = op[1] & 0x03; 8276 #line 879 "rx-decode.opc" 8277 int rsrc AU = (op[2] >> 4) & 0x0f; 8278 #line 879 "rx-decode.opc" 8279 int rdst AU = op[2] & 0x0f; 8280 if (trace) 8281 { 8282 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8283 "/** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */", 8284 op[0], op[1], op[2]); 8285 printf (" sd = 0x%x,", sd); 8286 printf (" rsrc = 0x%x,", rsrc); 8287 printf (" rdst = 0x%x\n", rdst); 8288 } 8289 SYNTAX("fdiv %1%S1, %0"); 8290 #line 879 "rx-decode.opc" 8291 ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8292 8293 } 8294 break; 8295 } 8296 break; 8297 case 0x91: 8298 GETBYTE (); 8299 switch (op[2] & 0x00) 8300 { 8301 case 0x00: 8302 goto op_semantics_65; 8303 break; 8304 } 8305 break; 8306 case 0x92: 8307 GETBYTE (); 8308 switch (op[2] & 0x00) 8309 { 8310 case 0x00: 8311 goto op_semantics_65; 8312 break; 8313 } 8314 break; 8315 case 0x93: 8316 GETBYTE (); 8317 switch (op[2] & 0x00) 8318 { 8319 case 0x00: 8320 goto op_semantics_65; 8321 break; 8322 } 8323 break; 8324 case 0x94: 8325 GETBYTE (); 8326 switch (op[2] & 0x00) 8327 { 8328 case 0x00: 8329 op_semantics_66: 8330 { 8331 /** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */ 8332 #line 867 "rx-decode.opc" 8333 int sd AU = op[1] & 0x03; 8334 #line 867 "rx-decode.opc" 8335 int rsrc AU = (op[2] >> 4) & 0x0f; 8336 #line 867 "rx-decode.opc" 8337 int rdst AU = op[2] & 0x0f; 8338 if (trace) 8339 { 8340 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8341 "/** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */", 8342 op[0], op[1], op[2]); 8343 printf (" sd = 0x%x,", sd); 8344 printf (" rsrc = 0x%x,", rsrc); 8345 printf (" rdst = 0x%x\n", rdst); 8346 } 8347 SYNTAX("ftoi %1%S1, %0"); 8348 #line 867 "rx-decode.opc" 8349 ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8350 8351 } 8352 break; 8353 } 8354 break; 8355 case 0x95: 8356 GETBYTE (); 8357 switch (op[2] & 0x00) 8358 { 8359 case 0x00: 8360 goto op_semantics_66; 8361 break; 8362 } 8363 break; 8364 case 0x96: 8365 GETBYTE (); 8366 switch (op[2] & 0x00) 8367 { 8368 case 0x00: 8369 goto op_semantics_66; 8370 break; 8371 } 8372 break; 8373 case 0x97: 8374 GETBYTE (); 8375 switch (op[2] & 0x00) 8376 { 8377 case 0x00: 8378 goto op_semantics_66; 8379 break; 8380 } 8381 break; 8382 case 0x98: 8383 GETBYTE (); 8384 switch (op[2] & 0x00) 8385 { 8386 case 0x00: 8387 op_semantics_67: 8388 { 8389 /** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */ 8390 #line 882 "rx-decode.opc" 8391 int sd AU = op[1] & 0x03; 8392 #line 882 "rx-decode.opc" 8393 int rsrc AU = (op[2] >> 4) & 0x0f; 8394 #line 882 "rx-decode.opc" 8395 int rdst AU = op[2] & 0x0f; 8396 if (trace) 8397 { 8398 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8399 "/** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */", 8400 op[0], op[1], op[2]); 8401 printf (" sd = 0x%x,", sd); 8402 printf (" rsrc = 0x%x,", rsrc); 8403 printf (" rdst = 0x%x\n", rdst); 8404 } 8405 SYNTAX("round %1%S1, %0"); 8406 #line 882 "rx-decode.opc" 8407 ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8408 8409 } 8410 break; 8411 } 8412 break; 8413 case 0x99: 8414 GETBYTE (); 8415 switch (op[2] & 0x00) 8416 { 8417 case 0x00: 8418 goto op_semantics_67; 8419 break; 8420 } 8421 break; 8422 case 0x9a: 8423 GETBYTE (); 8424 switch (op[2] & 0x00) 8425 { 8426 case 0x00: 8427 goto op_semantics_67; 8428 break; 8429 } 8430 break; 8431 case 0x9b: 8432 GETBYTE (); 8433 switch (op[2] & 0x00) 8434 { 8435 case 0x00: 8436 goto op_semantics_67; 8437 break; 8438 } 8439 break; 8440 case 0xd0: 8441 GETBYTE (); 8442 switch (op[2] & 0x00) 8443 { 8444 case 0x00: 8445 op_semantics_68: 8446 { 8447 /** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */ 8448 #line 999 "rx-decode.opc" 8449 int sz AU = (op[1] >> 2) & 0x03; 8450 #line 999 "rx-decode.opc" 8451 int sd AU = op[1] & 0x03; 8452 #line 999 "rx-decode.opc" 8453 int rdst AU = (op[2] >> 4) & 0x0f; 8454 #line 999 "rx-decode.opc" 8455 int cond AU = op[2] & 0x0f; 8456 if (trace) 8457 { 8458 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8459 "/** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */", 8460 op[0], op[1], op[2]); 8461 printf (" sz = 0x%x,", sz); 8462 printf (" sd = 0x%x,", sd); 8463 printf (" rdst = 0x%x,", rdst); 8464 printf (" cond = 0x%x\n", cond); 8465 } 8466 SYNTAX("sc%1%s %0"); 8467 #line 999 "rx-decode.opc" 8468 ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond); 8469 8470 } 8471 break; 8472 } 8473 break; 8474 case 0xd1: 8475 GETBYTE (); 8476 switch (op[2] & 0x00) 8477 { 8478 case 0x00: 8479 goto op_semantics_68; 8480 break; 8481 } 8482 break; 8483 case 0xd2: 8484 GETBYTE (); 8485 switch (op[2] & 0x00) 8486 { 8487 case 0x00: 8488 goto op_semantics_68; 8489 break; 8490 } 8491 break; 8492 case 0xd3: 8493 GETBYTE (); 8494 switch (op[2] & 0x00) 8495 { 8496 case 0x00: 8497 goto op_semantics_68; 8498 break; 8499 } 8500 break; 8501 case 0xd4: 8502 GETBYTE (); 8503 switch (op[2] & 0x00) 8504 { 8505 case 0x00: 8506 goto op_semantics_68; 8507 break; 8508 } 8509 break; 8510 case 0xd5: 8511 GETBYTE (); 8512 switch (op[2] & 0x00) 8513 { 8514 case 0x00: 8515 goto op_semantics_68; 8516 break; 8517 } 8518 break; 8519 case 0xd6: 8520 GETBYTE (); 8521 switch (op[2] & 0x00) 8522 { 8523 case 0x00: 8524 goto op_semantics_68; 8525 break; 8526 } 8527 break; 8528 case 0xd7: 8529 GETBYTE (); 8530 switch (op[2] & 0x00) 8531 { 8532 case 0x00: 8533 goto op_semantics_68; 8534 break; 8535 } 8536 break; 8537 case 0xd8: 8538 GETBYTE (); 8539 switch (op[2] & 0x00) 8540 { 8541 case 0x00: 8542 goto op_semantics_68; 8543 break; 8544 } 8545 break; 8546 case 0xd9: 8547 GETBYTE (); 8548 switch (op[2] & 0x00) 8549 { 8550 case 0x00: 8551 goto op_semantics_68; 8552 break; 8553 } 8554 break; 8555 case 0xda: 8556 GETBYTE (); 8557 switch (op[2] & 0x00) 8558 { 8559 case 0x00: 8560 goto op_semantics_68; 8561 break; 8562 } 8563 break; 8564 case 0xdb: 8565 GETBYTE (); 8566 switch (op[2] & 0x00) 8567 { 8568 case 0x00: 8569 goto op_semantics_68; 8570 break; 8571 } 8572 break; 8573 case 0xe0: 8574 GETBYTE (); 8575 switch (op[2] & 0x0f) 8576 { 8577 case 0x00: 8578 case 0x01: 8579 case 0x02: 8580 case 0x03: 8581 case 0x04: 8582 case 0x05: 8583 case 0x06: 8584 case 0x07: 8585 case 0x08: 8586 case 0x09: 8587 case 0x0a: 8588 case 0x0b: 8589 case 0x0c: 8590 case 0x0d: 8591 case 0x0e: 8592 op_semantics_69: 8593 { 8594 /** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */ 8595 #line 942 "rx-decode.opc" 8596 int bit AU = (op[1] >> 2) & 0x07; 8597 #line 942 "rx-decode.opc" 8598 int sd AU = op[1] & 0x03; 8599 #line 942 "rx-decode.opc" 8600 int rdst AU = (op[2] >> 4) & 0x0f; 8601 #line 942 "rx-decode.opc" 8602 int cond AU = op[2] & 0x0f; 8603 if (trace) 8604 { 8605 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8606 "/** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */", 8607 op[0], op[1], op[2]); 8608 printf (" bit = 0x%x,", bit); 8609 printf (" sd = 0x%x,", sd); 8610 printf (" rdst = 0x%x,", rdst); 8611 printf (" cond = 0x%x\n", cond); 8612 } 8613 SYNTAX("bm%2 #%1, %0%S0"); 8614 #line 942 "rx-decode.opc" 8615 ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE); 8616 8617 } 8618 break; 8619 case 0x0f: 8620 op_semantics_70: 8621 { 8622 /** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */ 8623 #line 930 "rx-decode.opc" 8624 int bit AU = (op[1] >> 2) & 0x07; 8625 #line 930 "rx-decode.opc" 8626 int sd AU = op[1] & 0x03; 8627 #line 930 "rx-decode.opc" 8628 int rdst AU = (op[2] >> 4) & 0x0f; 8629 if (trace) 8630 { 8631 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8632 "/** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */", 8633 op[0], op[1], op[2]); 8634 printf (" bit = 0x%x,", bit); 8635 printf (" sd = 0x%x,", sd); 8636 printf (" rdst = 0x%x\n", rdst); 8637 } 8638 SYNTAX("bnot #%1, %0%S0"); 8639 #line 930 "rx-decode.opc" 8640 ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); 8641 8642 } 8643 break; 8644 } 8645 break; 8646 case 0xe1: 8647 GETBYTE (); 8648 switch (op[2] & 0x0f) 8649 { 8650 case 0x00: 8651 case 0x01: 8652 case 0x02: 8653 case 0x03: 8654 case 0x04: 8655 case 0x05: 8656 case 0x06: 8657 case 0x07: 8658 case 0x08: 8659 case 0x09: 8660 case 0x0a: 8661 case 0x0b: 8662 case 0x0c: 8663 case 0x0d: 8664 case 0x0e: 8665 goto op_semantics_69; 8666 break; 8667 case 0x0f: 8668 goto op_semantics_70; 8669 break; 8670 } 8671 break; 8672 case 0xe2: 8673 GETBYTE (); 8674 switch (op[2] & 0x0f) 8675 { 8676 case 0x00: 8677 case 0x01: 8678 case 0x02: 8679 case 0x03: 8680 case 0x04: 8681 case 0x05: 8682 case 0x06: 8683 case 0x07: 8684 case 0x08: 8685 case 0x09: 8686 case 0x0a: 8687 case 0x0b: 8688 case 0x0c: 8689 case 0x0d: 8690 case 0x0e: 8691 goto op_semantics_69; 8692 break; 8693 case 0x0f: 8694 goto op_semantics_70; 8695 break; 8696 } 8697 break; 8698 case 0xe3: 8699 GETBYTE (); 8700 switch (op[2] & 0x0f) 8701 { 8702 case 0x00: 8703 case 0x01: 8704 case 0x02: 8705 case 0x03: 8706 case 0x04: 8707 case 0x05: 8708 case 0x06: 8709 case 0x07: 8710 case 0x08: 8711 case 0x09: 8712 case 0x0a: 8713 case 0x0b: 8714 case 0x0c: 8715 case 0x0d: 8716 case 0x0e: 8717 goto op_semantics_69; 8718 break; 8719 case 0x0f: 8720 goto op_semantics_70; 8721 break; 8722 } 8723 break; 8724 case 0xe4: 8725 GETBYTE (); 8726 switch (op[2] & 0x0f) 8727 { 8728 case 0x00: 8729 case 0x01: 8730 case 0x02: 8731 case 0x03: 8732 case 0x04: 8733 case 0x05: 8734 case 0x06: 8735 case 0x07: 8736 case 0x08: 8737 case 0x09: 8738 case 0x0a: 8739 case 0x0b: 8740 case 0x0c: 8741 case 0x0d: 8742 case 0x0e: 8743 goto op_semantics_69; 8744 break; 8745 case 0x0f: 8746 goto op_semantics_70; 8747 break; 8748 } 8749 break; 8750 case 0xe5: 8751 GETBYTE (); 8752 switch (op[2] & 0x0f) 8753 { 8754 case 0x00: 8755 case 0x01: 8756 case 0x02: 8757 case 0x03: 8758 case 0x04: 8759 case 0x05: 8760 case 0x06: 8761 case 0x07: 8762 case 0x08: 8763 case 0x09: 8764 case 0x0a: 8765 case 0x0b: 8766 case 0x0c: 8767 case 0x0d: 8768 case 0x0e: 8769 goto op_semantics_69; 8770 break; 8771 case 0x0f: 8772 goto op_semantics_70; 8773 break; 8774 } 8775 break; 8776 case 0xe6: 8777 GETBYTE (); 8778 switch (op[2] & 0x0f) 8779 { 8780 case 0x00: 8781 case 0x01: 8782 case 0x02: 8783 case 0x03: 8784 case 0x04: 8785 case 0x05: 8786 case 0x06: 8787 case 0x07: 8788 case 0x08: 8789 case 0x09: 8790 case 0x0a: 8791 case 0x0b: 8792 case 0x0c: 8793 case 0x0d: 8794 case 0x0e: 8795 goto op_semantics_69; 8796 break; 8797 case 0x0f: 8798 goto op_semantics_70; 8799 break; 8800 } 8801 break; 8802 case 0xe7: 8803 GETBYTE (); 8804 switch (op[2] & 0x0f) 8805 { 8806 case 0x00: 8807 case 0x01: 8808 case 0x02: 8809 case 0x03: 8810 case 0x04: 8811 case 0x05: 8812 case 0x06: 8813 case 0x07: 8814 case 0x08: 8815 case 0x09: 8816 case 0x0a: 8817 case 0x0b: 8818 case 0x0c: 8819 case 0x0d: 8820 case 0x0e: 8821 goto op_semantics_69; 8822 break; 8823 case 0x0f: 8824 goto op_semantics_70; 8825 break; 8826 } 8827 break; 8828 case 0xe8: 8829 GETBYTE (); 8830 switch (op[2] & 0x0f) 8831 { 8832 case 0x00: 8833 case 0x01: 8834 case 0x02: 8835 case 0x03: 8836 case 0x04: 8837 case 0x05: 8838 case 0x06: 8839 case 0x07: 8840 case 0x08: 8841 case 0x09: 8842 case 0x0a: 8843 case 0x0b: 8844 case 0x0c: 8845 case 0x0d: 8846 case 0x0e: 8847 goto op_semantics_69; 8848 break; 8849 case 0x0f: 8850 goto op_semantics_70; 8851 break; 8852 } 8853 break; 8854 case 0xe9: 8855 GETBYTE (); 8856 switch (op[2] & 0x0f) 8857 { 8858 case 0x00: 8859 case 0x01: 8860 case 0x02: 8861 case 0x03: 8862 case 0x04: 8863 case 0x05: 8864 case 0x06: 8865 case 0x07: 8866 case 0x08: 8867 case 0x09: 8868 case 0x0a: 8869 case 0x0b: 8870 case 0x0c: 8871 case 0x0d: 8872 case 0x0e: 8873 goto op_semantics_69; 8874 break; 8875 case 0x0f: 8876 goto op_semantics_70; 8877 break; 8878 } 8879 break; 8880 case 0xea: 8881 GETBYTE (); 8882 switch (op[2] & 0x0f) 8883 { 8884 case 0x00: 8885 case 0x01: 8886 case 0x02: 8887 case 0x03: 8888 case 0x04: 8889 case 0x05: 8890 case 0x06: 8891 case 0x07: 8892 case 0x08: 8893 case 0x09: 8894 case 0x0a: 8895 case 0x0b: 8896 case 0x0c: 8897 case 0x0d: 8898 case 0x0e: 8899 goto op_semantics_69; 8900 break; 8901 case 0x0f: 8902 goto op_semantics_70; 8903 break; 8904 } 8905 break; 8906 case 0xeb: 8907 GETBYTE (); 8908 switch (op[2] & 0x0f) 8909 { 8910 case 0x00: 8911 case 0x01: 8912 case 0x02: 8913 case 0x03: 8914 case 0x04: 8915 case 0x05: 8916 case 0x06: 8917 case 0x07: 8918 case 0x08: 8919 case 0x09: 8920 case 0x0a: 8921 case 0x0b: 8922 case 0x0c: 8923 case 0x0d: 8924 case 0x0e: 8925 goto op_semantics_69; 8926 break; 8927 case 0x0f: 8928 goto op_semantics_70; 8929 break; 8930 } 8931 break; 8932 case 0xec: 8933 GETBYTE (); 8934 switch (op[2] & 0x0f) 8935 { 8936 case 0x00: 8937 case 0x01: 8938 case 0x02: 8939 case 0x03: 8940 case 0x04: 8941 case 0x05: 8942 case 0x06: 8943 case 0x07: 8944 case 0x08: 8945 case 0x09: 8946 case 0x0a: 8947 case 0x0b: 8948 case 0x0c: 8949 case 0x0d: 8950 case 0x0e: 8951 goto op_semantics_69; 8952 break; 8953 case 0x0f: 8954 goto op_semantics_70; 8955 break; 8956 } 8957 break; 8958 case 0xed: 8959 GETBYTE (); 8960 switch (op[2] & 0x0f) 8961 { 8962 case 0x00: 8963 case 0x01: 8964 case 0x02: 8965 case 0x03: 8966 case 0x04: 8967 case 0x05: 8968 case 0x06: 8969 case 0x07: 8970 case 0x08: 8971 case 0x09: 8972 case 0x0a: 8973 case 0x0b: 8974 case 0x0c: 8975 case 0x0d: 8976 case 0x0e: 8977 goto op_semantics_69; 8978 break; 8979 case 0x0f: 8980 goto op_semantics_70; 8981 break; 8982 } 8983 break; 8984 case 0xee: 8985 GETBYTE (); 8986 switch (op[2] & 0x0f) 8987 { 8988 case 0x00: 8989 case 0x01: 8990 case 0x02: 8991 case 0x03: 8992 case 0x04: 8993 case 0x05: 8994 case 0x06: 8995 case 0x07: 8996 case 0x08: 8997 case 0x09: 8998 case 0x0a: 8999 case 0x0b: 9000 case 0x0c: 9001 case 0x0d: 9002 case 0x0e: 9003 goto op_semantics_69; 9004 break; 9005 case 0x0f: 9006 goto op_semantics_70; 9007 break; 9008 } 9009 break; 9010 case 0xef: 9011 GETBYTE (); 9012 switch (op[2] & 0x0f) 9013 { 9014 case 0x00: 9015 case 0x01: 9016 case 0x02: 9017 case 0x03: 9018 case 0x04: 9019 case 0x05: 9020 case 0x06: 9021 case 0x07: 9022 case 0x08: 9023 case 0x09: 9024 case 0x0a: 9025 case 0x0b: 9026 case 0x0c: 9027 case 0x0d: 9028 case 0x0e: 9029 goto op_semantics_69; 9030 break; 9031 case 0x0f: 9032 goto op_semantics_70; 9033 break; 9034 } 9035 break; 9036 case 0xf0: 9037 GETBYTE (); 9038 switch (op[2] & 0x0f) 9039 { 9040 case 0x00: 9041 case 0x01: 9042 case 0x02: 9043 case 0x03: 9044 case 0x04: 9045 case 0x05: 9046 case 0x06: 9047 case 0x07: 9048 case 0x08: 9049 case 0x09: 9050 case 0x0a: 9051 case 0x0b: 9052 case 0x0c: 9053 case 0x0d: 9054 case 0x0e: 9055 goto op_semantics_69; 9056 break; 9057 case 0x0f: 9058 goto op_semantics_70; 9059 break; 9060 } 9061 break; 9062 case 0xf1: 9063 GETBYTE (); 9064 switch (op[2] & 0x0f) 9065 { 9066 case 0x00: 9067 case 0x01: 9068 case 0x02: 9069 case 0x03: 9070 case 0x04: 9071 case 0x05: 9072 case 0x06: 9073 case 0x07: 9074 case 0x08: 9075 case 0x09: 9076 case 0x0a: 9077 case 0x0b: 9078 case 0x0c: 9079 case 0x0d: 9080 case 0x0e: 9081 goto op_semantics_69; 9082 break; 9083 case 0x0f: 9084 goto op_semantics_70; 9085 break; 9086 } 9087 break; 9088 case 0xf2: 9089 GETBYTE (); 9090 switch (op[2] & 0x0f) 9091 { 9092 case 0x00: 9093 case 0x01: 9094 case 0x02: 9095 case 0x03: 9096 case 0x04: 9097 case 0x05: 9098 case 0x06: 9099 case 0x07: 9100 case 0x08: 9101 case 0x09: 9102 case 0x0a: 9103 case 0x0b: 9104 case 0x0c: 9105 case 0x0d: 9106 case 0x0e: 9107 goto op_semantics_69; 9108 break; 9109 case 0x0f: 9110 goto op_semantics_70; 9111 break; 9112 } 9113 break; 9114 case 0xf3: 9115 GETBYTE (); 9116 switch (op[2] & 0x0f) 9117 { 9118 case 0x00: 9119 case 0x01: 9120 case 0x02: 9121 case 0x03: 9122 case 0x04: 9123 case 0x05: 9124 case 0x06: 9125 case 0x07: 9126 case 0x08: 9127 case 0x09: 9128 case 0x0a: 9129 case 0x0b: 9130 case 0x0c: 9131 case 0x0d: 9132 case 0x0e: 9133 goto op_semantics_69; 9134 break; 9135 case 0x0f: 9136 goto op_semantics_70; 9137 break; 9138 } 9139 break; 9140 case 0xf4: 9141 GETBYTE (); 9142 switch (op[2] & 0x0f) 9143 { 9144 case 0x00: 9145 case 0x01: 9146 case 0x02: 9147 case 0x03: 9148 case 0x04: 9149 case 0x05: 9150 case 0x06: 9151 case 0x07: 9152 case 0x08: 9153 case 0x09: 9154 case 0x0a: 9155 case 0x0b: 9156 case 0x0c: 9157 case 0x0d: 9158 case 0x0e: 9159 goto op_semantics_69; 9160 break; 9161 case 0x0f: 9162 goto op_semantics_70; 9163 break; 9164 } 9165 break; 9166 case 0xf5: 9167 GETBYTE (); 9168 switch (op[2] & 0x0f) 9169 { 9170 case 0x00: 9171 case 0x01: 9172 case 0x02: 9173 case 0x03: 9174 case 0x04: 9175 case 0x05: 9176 case 0x06: 9177 case 0x07: 9178 case 0x08: 9179 case 0x09: 9180 case 0x0a: 9181 case 0x0b: 9182 case 0x0c: 9183 case 0x0d: 9184 case 0x0e: 9185 goto op_semantics_69; 9186 break; 9187 case 0x0f: 9188 goto op_semantics_70; 9189 break; 9190 } 9191 break; 9192 case 0xf6: 9193 GETBYTE (); 9194 switch (op[2] & 0x0f) 9195 { 9196 case 0x00: 9197 case 0x01: 9198 case 0x02: 9199 case 0x03: 9200 case 0x04: 9201 case 0x05: 9202 case 0x06: 9203 case 0x07: 9204 case 0x08: 9205 case 0x09: 9206 case 0x0a: 9207 case 0x0b: 9208 case 0x0c: 9209 case 0x0d: 9210 case 0x0e: 9211 goto op_semantics_69; 9212 break; 9213 case 0x0f: 9214 goto op_semantics_70; 9215 break; 9216 } 9217 break; 9218 case 0xf7: 9219 GETBYTE (); 9220 switch (op[2] & 0x0f) 9221 { 9222 case 0x00: 9223 case 0x01: 9224 case 0x02: 9225 case 0x03: 9226 case 0x04: 9227 case 0x05: 9228 case 0x06: 9229 case 0x07: 9230 case 0x08: 9231 case 0x09: 9232 case 0x0a: 9233 case 0x0b: 9234 case 0x0c: 9235 case 0x0d: 9236 case 0x0e: 9237 goto op_semantics_69; 9238 break; 9239 case 0x0f: 9240 goto op_semantics_70; 9241 break; 9242 } 9243 break; 9244 case 0xf8: 9245 GETBYTE (); 9246 switch (op[2] & 0x0f) 9247 { 9248 case 0x00: 9249 case 0x01: 9250 case 0x02: 9251 case 0x03: 9252 case 0x04: 9253 case 0x05: 9254 case 0x06: 9255 case 0x07: 9256 case 0x08: 9257 case 0x09: 9258 case 0x0a: 9259 case 0x0b: 9260 case 0x0c: 9261 case 0x0d: 9262 case 0x0e: 9263 goto op_semantics_69; 9264 break; 9265 case 0x0f: 9266 goto op_semantics_70; 9267 break; 9268 } 9269 break; 9270 case 0xf9: 9271 GETBYTE (); 9272 switch (op[2] & 0x0f) 9273 { 9274 case 0x00: 9275 case 0x01: 9276 case 0x02: 9277 case 0x03: 9278 case 0x04: 9279 case 0x05: 9280 case 0x06: 9281 case 0x07: 9282 case 0x08: 9283 case 0x09: 9284 case 0x0a: 9285 case 0x0b: 9286 case 0x0c: 9287 case 0x0d: 9288 case 0x0e: 9289 goto op_semantics_69; 9290 break; 9291 case 0x0f: 9292 goto op_semantics_70; 9293 break; 9294 } 9295 break; 9296 case 0xfa: 9297 GETBYTE (); 9298 switch (op[2] & 0x0f) 9299 { 9300 case 0x00: 9301 case 0x01: 9302 case 0x02: 9303 case 0x03: 9304 case 0x04: 9305 case 0x05: 9306 case 0x06: 9307 case 0x07: 9308 case 0x08: 9309 case 0x09: 9310 case 0x0a: 9311 case 0x0b: 9312 case 0x0c: 9313 case 0x0d: 9314 case 0x0e: 9315 goto op_semantics_69; 9316 break; 9317 case 0x0f: 9318 goto op_semantics_70; 9319 break; 9320 } 9321 break; 9322 case 0xfb: 9323 GETBYTE (); 9324 switch (op[2] & 0x0f) 9325 { 9326 case 0x00: 9327 case 0x01: 9328 case 0x02: 9329 case 0x03: 9330 case 0x04: 9331 case 0x05: 9332 case 0x06: 9333 case 0x07: 9334 case 0x08: 9335 case 0x09: 9336 case 0x0a: 9337 case 0x0b: 9338 case 0x0c: 9339 case 0x0d: 9340 case 0x0e: 9341 goto op_semantics_69; 9342 break; 9343 case 0x0f: 9344 goto op_semantics_70; 9345 break; 9346 } 9347 break; 9348 case 0xfc: 9349 GETBYTE (); 9350 switch (op[2] & 0x0f) 9351 { 9352 case 0x00: 9353 case 0x01: 9354 case 0x02: 9355 case 0x03: 9356 case 0x04: 9357 case 0x05: 9358 case 0x06: 9359 case 0x07: 9360 case 0x08: 9361 case 0x09: 9362 case 0x0a: 9363 case 0x0b: 9364 case 0x0c: 9365 case 0x0d: 9366 case 0x0e: 9367 goto op_semantics_69; 9368 break; 9369 case 0x0f: 9370 goto op_semantics_70; 9371 break; 9372 } 9373 break; 9374 case 0xfd: 9375 GETBYTE (); 9376 switch (op[2] & 0x0f) 9377 { 9378 case 0x00: 9379 case 0x01: 9380 case 0x02: 9381 case 0x03: 9382 case 0x04: 9383 case 0x05: 9384 case 0x06: 9385 case 0x07: 9386 case 0x08: 9387 case 0x09: 9388 case 0x0a: 9389 case 0x0b: 9390 case 0x0c: 9391 case 0x0d: 9392 case 0x0e: 9393 goto op_semantics_69; 9394 break; 9395 case 0x0f: 9396 goto op_semantics_70; 9397 break; 9398 } 9399 break; 9400 case 0xfe: 9401 GETBYTE (); 9402 switch (op[2] & 0x0f) 9403 { 9404 case 0x00: 9405 case 0x01: 9406 case 0x02: 9407 case 0x03: 9408 case 0x04: 9409 case 0x05: 9410 case 0x06: 9411 case 0x07: 9412 case 0x08: 9413 case 0x09: 9414 case 0x0a: 9415 case 0x0b: 9416 case 0x0c: 9417 case 0x0d: 9418 case 0x0e: 9419 goto op_semantics_69; 9420 break; 9421 case 0x0f: 9422 goto op_semantics_70; 9423 break; 9424 } 9425 break; 9426 case 0xff: 9427 GETBYTE (); 9428 switch (op[2] & 0x0f) 9429 { 9430 case 0x00: 9431 case 0x01: 9432 case 0x02: 9433 case 0x03: 9434 case 0x04: 9435 case 0x05: 9436 case 0x06: 9437 case 0x07: 9438 case 0x08: 9439 case 0x09: 9440 case 0x0a: 9441 case 0x0b: 9442 case 0x0c: 9443 case 0x0d: 9444 case 0x0e: 9445 goto op_semantics_69; 9446 break; 9447 case 0x0f: 9448 goto op_semantics_70; 9449 break; 9450 } 9451 break; 9452 default: UNSUPPORTED(); break; 9453 } 9454 break; 9455 case 0xfd: 9456 GETBYTE (); 9457 switch (op[1] & 0xff) 9458 { 9459 case 0x00: 9460 GETBYTE (); 9461 switch (op[2] & 0x00) 9462 { 9463 case 0x00: 9464 { 9465 /** 1111 1101 0000 0000 srca srcb mulhi %1, %2 */ 9466 #line 807 "rx-decode.opc" 9467 int srca AU = (op[2] >> 4) & 0x0f; 9468 #line 807 "rx-decode.opc" 9469 int srcb AU = op[2] & 0x0f; 9470 if (trace) 9471 { 9472 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9473 "/** 1111 1101 0000 0000 srca srcb mulhi %1, %2 */", 9474 op[0], op[1], op[2]); 9475 printf (" srca = 0x%x,", srca); 9476 printf (" srcb = 0x%x\n", srcb); 9477 } 9478 SYNTAX("mulhi %1, %2"); 9479 #line 807 "rx-decode.opc" 9480 ID(mulhi); SR(srca); S2R(srcb); F_____; 9481 9482 } 9483 break; 9484 } 9485 break; 9486 case 0x01: 9487 GETBYTE (); 9488 switch (op[2] & 0x00) 9489 { 9490 case 0x00: 9491 { 9492 /** 1111 1101 0000 0001 srca srcb mullo %1, %2 */ 9493 #line 810 "rx-decode.opc" 9494 int srca AU = (op[2] >> 4) & 0x0f; 9495 #line 810 "rx-decode.opc" 9496 int srcb AU = op[2] & 0x0f; 9497 if (trace) 9498 { 9499 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9500 "/** 1111 1101 0000 0001 srca srcb mullo %1, %2 */", 9501 op[0], op[1], op[2]); 9502 printf (" srca = 0x%x,", srca); 9503 printf (" srcb = 0x%x\n", srcb); 9504 } 9505 SYNTAX("mullo %1, %2"); 9506 #line 810 "rx-decode.opc" 9507 ID(mullo); SR(srca); S2R(srcb); F_____; 9508 9509 } 9510 break; 9511 } 9512 break; 9513 case 0x04: 9514 GETBYTE (); 9515 switch (op[2] & 0x00) 9516 { 9517 case 0x00: 9518 { 9519 /** 1111 1101 0000 0100 srca srcb machi %1, %2 */ 9520 #line 813 "rx-decode.opc" 9521 int srca AU = (op[2] >> 4) & 0x0f; 9522 #line 813 "rx-decode.opc" 9523 int srcb AU = op[2] & 0x0f; 9524 if (trace) 9525 { 9526 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9527 "/** 1111 1101 0000 0100 srca srcb machi %1, %2 */", 9528 op[0], op[1], op[2]); 9529 printf (" srca = 0x%x,", srca); 9530 printf (" srcb = 0x%x\n", srcb); 9531 } 9532 SYNTAX("machi %1, %2"); 9533 #line 813 "rx-decode.opc" 9534 ID(machi); SR(srca); S2R(srcb); F_____; 9535 9536 } 9537 break; 9538 } 9539 break; 9540 case 0x05: 9541 GETBYTE (); 9542 switch (op[2] & 0x00) 9543 { 9544 case 0x00: 9545 { 9546 /** 1111 1101 0000 0101 srca srcb maclo %1, %2 */ 9547 #line 816 "rx-decode.opc" 9548 int srca AU = (op[2] >> 4) & 0x0f; 9549 #line 816 "rx-decode.opc" 9550 int srcb AU = op[2] & 0x0f; 9551 if (trace) 9552 { 9553 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9554 "/** 1111 1101 0000 0101 srca srcb maclo %1, %2 */", 9555 op[0], op[1], op[2]); 9556 printf (" srca = 0x%x,", srca); 9557 printf (" srcb = 0x%x\n", srcb); 9558 } 9559 SYNTAX("maclo %1, %2"); 9560 #line 816 "rx-decode.opc" 9561 ID(maclo); SR(srca); S2R(srcb); F_____; 9562 9563 } 9564 break; 9565 } 9566 break; 9567 case 0x17: 9568 GETBYTE (); 9569 switch (op[2] & 0xf0) 9570 { 9571 case 0x00: 9572 { 9573 /** 1111 1101 0001 0111 0000 rsrc mvtachi %1 */ 9574 #line 819 "rx-decode.opc" 9575 int rsrc AU = op[2] & 0x0f; 9576 if (trace) 9577 { 9578 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9579 "/** 1111 1101 0001 0111 0000 rsrc mvtachi %1 */", 9580 op[0], op[1], op[2]); 9581 printf (" rsrc = 0x%x\n", rsrc); 9582 } 9583 SYNTAX("mvtachi %1"); 9584 #line 819 "rx-decode.opc" 9585 ID(mvtachi); SR(rsrc); F_____; 9586 9587 } 9588 break; 9589 case 0x10: 9590 { 9591 /** 1111 1101 0001 0111 0001 rsrc mvtaclo %1 */ 9592 #line 822 "rx-decode.opc" 9593 int rsrc AU = op[2] & 0x0f; 9594 if (trace) 9595 { 9596 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9597 "/** 1111 1101 0001 0111 0001 rsrc mvtaclo %1 */", 9598 op[0], op[1], op[2]); 9599 printf (" rsrc = 0x%x\n", rsrc); 9600 } 9601 SYNTAX("mvtaclo %1"); 9602 #line 822 "rx-decode.opc" 9603 ID(mvtaclo); SR(rsrc); F_____; 9604 9605 } 9606 break; 9607 default: UNSUPPORTED(); break; 9608 } 9609 break; 9610 case 0x18: 9611 GETBYTE (); 9612 switch (op[2] & 0xef) 9613 { 9614 case 0x00: 9615 { 9616 /** 1111 1101 0001 1000 000i 0000 racw #%1 */ 9617 #line 834 "rx-decode.opc" 9618 int i AU = (op[2] >> 4) & 0x01; 9619 if (trace) 9620 { 9621 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9622 "/** 1111 1101 0001 1000 000i 0000 racw #%1 */", 9623 op[0], op[1], op[2]); 9624 printf (" i = 0x%x\n", i); 9625 } 9626 SYNTAX("racw #%1"); 9627 #line 834 "rx-decode.opc" 9628 ID(racw); SC(i+1); F_____; 9629 9630 /*----------------------------------------------------------------------*/ 9631 /* SAT */ 9632 9633 } 9634 break; 9635 default: UNSUPPORTED(); break; 9636 } 9637 break; 9638 case 0x1f: 9639 GETBYTE (); 9640 switch (op[2] & 0xf0) 9641 { 9642 case 0x00: 9643 { 9644 /** 1111 1101 0001 1111 0000 rdst mvfachi %0 */ 9645 #line 825 "rx-decode.opc" 9646 int rdst AU = op[2] & 0x0f; 9647 if (trace) 9648 { 9649 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9650 "/** 1111 1101 0001 1111 0000 rdst mvfachi %0 */", 9651 op[0], op[1], op[2]); 9652 printf (" rdst = 0x%x\n", rdst); 9653 } 9654 SYNTAX("mvfachi %0"); 9655 #line 825 "rx-decode.opc" 9656 ID(mvfachi); DR(rdst); F_____; 9657 9658 } 9659 break; 9660 case 0x10: 9661 { 9662 /** 1111 1101 0001 1111 0001 rdst mvfaclo %0 */ 9663 #line 831 "rx-decode.opc" 9664 int rdst AU = op[2] & 0x0f; 9665 if (trace) 9666 { 9667 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9668 "/** 1111 1101 0001 1111 0001 rdst mvfaclo %0 */", 9669 op[0], op[1], op[2]); 9670 printf (" rdst = 0x%x\n", rdst); 9671 } 9672 SYNTAX("mvfaclo %0"); 9673 #line 831 "rx-decode.opc" 9674 ID(mvfaclo); DR(rdst); F_____; 9675 9676 } 9677 break; 9678 case 0x20: 9679 { 9680 /** 1111 1101 0001 1111 0010 rdst mvfacmi %0 */ 9681 #line 828 "rx-decode.opc" 9682 int rdst AU = op[2] & 0x0f; 9683 if (trace) 9684 { 9685 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9686 "/** 1111 1101 0001 1111 0010 rdst mvfacmi %0 */", 9687 op[0], op[1], op[2]); 9688 printf (" rdst = 0x%x\n", rdst); 9689 } 9690 SYNTAX("mvfacmi %0"); 9691 #line 828 "rx-decode.opc" 9692 ID(mvfacmi); DR(rdst); F_____; 9693 9694 } 9695 break; 9696 default: UNSUPPORTED(); break; 9697 } 9698 break; 9699 case 0x20: 9700 GETBYTE (); 9701 switch (op[2] & 0x00) 9702 { 9703 case 0x00: 9704 op_semantics_71: 9705 { 9706 /** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */ 9707 #line 341 "rx-decode.opc" 9708 int p AU = (op[1] >> 2) & 0x01; 9709 #line 341 "rx-decode.opc" 9710 int sz AU = op[1] & 0x03; 9711 #line 341 "rx-decode.opc" 9712 int rdst AU = (op[2] >> 4) & 0x0f; 9713 #line 341 "rx-decode.opc" 9714 int rsrc AU = op[2] & 0x0f; 9715 if (trace) 9716 { 9717 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9718 "/** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */", 9719 op[0], op[1], op[2]); 9720 printf (" p = 0x%x,", p); 9721 printf (" sz = 0x%x,", sz); 9722 printf (" rdst = 0x%x,", rdst); 9723 printf (" rsrc = 0x%x\n", rsrc); 9724 } 9725 SYNTAX("mov%s %1, %0"); 9726 #line 341 "rx-decode.opc" 9727 ID(mov); sBWL (sz); SR(rsrc); F_____; 9728 OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0); 9729 9730 } 9731 break; 9732 } 9733 break; 9734 case 0x21: 9735 GETBYTE (); 9736 switch (op[2] & 0x00) 9737 { 9738 case 0x00: 9739 goto op_semantics_71; 9740 break; 9741 } 9742 break; 9743 case 0x22: 9744 GETBYTE (); 9745 switch (op[2] & 0x00) 9746 { 9747 case 0x00: 9748 goto op_semantics_71; 9749 break; 9750 } 9751 break; 9752 case 0x24: 9753 GETBYTE (); 9754 switch (op[2] & 0x00) 9755 { 9756 case 0x00: 9757 goto op_semantics_71; 9758 break; 9759 } 9760 break; 9761 case 0x25: 9762 GETBYTE (); 9763 switch (op[2] & 0x00) 9764 { 9765 case 0x00: 9766 goto op_semantics_71; 9767 break; 9768 } 9769 break; 9770 case 0x26: 9771 GETBYTE (); 9772 switch (op[2] & 0x00) 9773 { 9774 case 0x00: 9775 goto op_semantics_71; 9776 break; 9777 } 9778 break; 9779 case 0x28: 9780 GETBYTE (); 9781 switch (op[2] & 0x00) 9782 { 9783 case 0x00: 9784 op_semantics_72: 9785 { 9786 /** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */ 9787 #line 345 "rx-decode.opc" 9788 int p AU = (op[1] >> 2) & 0x01; 9789 #line 345 "rx-decode.opc" 9790 int sz AU = op[1] & 0x03; 9791 #line 345 "rx-decode.opc" 9792 int rsrc AU = (op[2] >> 4) & 0x0f; 9793 #line 345 "rx-decode.opc" 9794 int rdst AU = op[2] & 0x0f; 9795 if (trace) 9796 { 9797 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9798 "/** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */", 9799 op[0], op[1], op[2]); 9800 printf (" p = 0x%x,", p); 9801 printf (" sz = 0x%x,", sz); 9802 printf (" rsrc = 0x%x,", rsrc); 9803 printf (" rdst = 0x%x\n", rdst); 9804 } 9805 SYNTAX("mov%s %1, %0"); 9806 #line 345 "rx-decode.opc" 9807 ID(mov); sBWL (sz); DR(rdst); F_____; 9808 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0); 9809 9810 } 9811 break; 9812 } 9813 break; 9814 case 0x29: 9815 GETBYTE (); 9816 switch (op[2] & 0x00) 9817 { 9818 case 0x00: 9819 goto op_semantics_72; 9820 break; 9821 } 9822 break; 9823 case 0x2a: 9824 GETBYTE (); 9825 switch (op[2] & 0x00) 9826 { 9827 case 0x00: 9828 goto op_semantics_72; 9829 break; 9830 } 9831 break; 9832 case 0x2c: 9833 GETBYTE (); 9834 switch (op[2] & 0x00) 9835 { 9836 case 0x00: 9837 goto op_semantics_72; 9838 break; 9839 } 9840 break; 9841 case 0x2d: 9842 GETBYTE (); 9843 switch (op[2] & 0x00) 9844 { 9845 case 0x00: 9846 goto op_semantics_72; 9847 break; 9848 } 9849 break; 9850 case 0x2e: 9851 GETBYTE (); 9852 switch (op[2] & 0x00) 9853 { 9854 case 0x00: 9855 goto op_semantics_72; 9856 break; 9857 } 9858 break; 9859 case 0x38: 9860 GETBYTE (); 9861 switch (op[2] & 0x00) 9862 { 9863 case 0x00: 9864 op_semantics_73: 9865 { 9866 /** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */ 9867 #line 355 "rx-decode.opc" 9868 int p AU = (op[1] >> 2) & 0x01; 9869 #line 355 "rx-decode.opc" 9870 int sz AU = op[1] & 0x03; 9871 #line 355 "rx-decode.opc" 9872 int rsrc AU = (op[2] >> 4) & 0x0f; 9873 #line 355 "rx-decode.opc" 9874 int rdst AU = op[2] & 0x0f; 9875 if (trace) 9876 { 9877 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9878 "/** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */", 9879 op[0], op[1], op[2]); 9880 printf (" p = 0x%x,", p); 9881 printf (" sz = 0x%x,", sz); 9882 printf (" rsrc = 0x%x,", rsrc); 9883 printf (" rdst = 0x%x\n", rdst); 9884 } 9885 SYNTAX("movu%s %1, %0"); 9886 #line 355 "rx-decode.opc" 9887 ID(mov); uBWL (sz); DR(rdst); F_____; 9888 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0); 9889 9890 /*----------------------------------------------------------------------*/ 9891 /* PUSH/POP */ 9892 9893 } 9894 break; 9895 } 9896 break; 9897 case 0x39: 9898 GETBYTE (); 9899 switch (op[2] & 0x00) 9900 { 9901 case 0x00: 9902 goto op_semantics_73; 9903 break; 9904 } 9905 break; 9906 case 0x3a: 9907 GETBYTE (); 9908 switch (op[2] & 0x00) 9909 { 9910 case 0x00: 9911 goto op_semantics_73; 9912 break; 9913 } 9914 break; 9915 case 0x3c: 9916 GETBYTE (); 9917 switch (op[2] & 0x00) 9918 { 9919 case 0x00: 9920 goto op_semantics_73; 9921 break; 9922 } 9923 break; 9924 case 0x3d: 9925 GETBYTE (); 9926 switch (op[2] & 0x00) 9927 { 9928 case 0x00: 9929 goto op_semantics_73; 9930 break; 9931 } 9932 break; 9933 case 0x3e: 9934 GETBYTE (); 9935 switch (op[2] & 0x00) 9936 { 9937 case 0x00: 9938 goto op_semantics_73; 9939 break; 9940 } 9941 break; 9942 case 0x60: 9943 GETBYTE (); 9944 switch (op[2] & 0x00) 9945 { 9946 case 0x00: 9947 { 9948 /** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */ 9949 #line 688 "rx-decode.opc" 9950 int rsrc AU = (op[2] >> 4) & 0x0f; 9951 #line 688 "rx-decode.opc" 9952 int rdst AU = op[2] & 0x0f; 9953 if (trace) 9954 { 9955 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9956 "/** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */", 9957 op[0], op[1], op[2]); 9958 printf (" rsrc = 0x%x,", rsrc); 9959 printf (" rdst = 0x%x\n", rdst); 9960 } 9961 SYNTAX("shlr %2, %0"); 9962 #line 688 "rx-decode.opc" 9963 ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F__SZC; 9964 9965 } 9966 break; 9967 } 9968 break; 9969 case 0x61: 9970 GETBYTE (); 9971 switch (op[2] & 0x00) 9972 { 9973 case 0x00: 9974 { 9975 /** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */ 9976 #line 678 "rx-decode.opc" 9977 int rsrc AU = (op[2] >> 4) & 0x0f; 9978 #line 678 "rx-decode.opc" 9979 int rdst AU = op[2] & 0x0f; 9980 if (trace) 9981 { 9982 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9983 "/** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */", 9984 op[0], op[1], op[2]); 9985 printf (" rsrc = 0x%x,", rsrc); 9986 printf (" rdst = 0x%x\n", rdst); 9987 } 9988 SYNTAX("shar %2, %0"); 9989 #line 678 "rx-decode.opc" 9990 ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F_0SZC; 9991 9992 } 9993 break; 9994 } 9995 break; 9996 case 0x62: 9997 GETBYTE (); 9998 switch (op[2] & 0x00) 9999 { 10000 case 0x00: 10001 { 10002 /** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */ 10003 #line 668 "rx-decode.opc" 10004 int rsrc AU = (op[2] >> 4) & 0x0f; 10005 #line 668 "rx-decode.opc" 10006 int rdst AU = op[2] & 0x0f; 10007 if (trace) 10008 { 10009 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10010 "/** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */", 10011 op[0], op[1], op[2]); 10012 printf (" rsrc = 0x%x,", rsrc); 10013 printf (" rdst = 0x%x\n", rdst); 10014 } 10015 SYNTAX("shll %2, %0"); 10016 #line 668 "rx-decode.opc" 10017 ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F_OSZC; 10018 10019 } 10020 break; 10021 } 10022 break; 10023 case 0x64: 10024 GETBYTE (); 10025 switch (op[2] & 0x00) 10026 { 10027 case 0x00: 10028 { 10029 /** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */ 10030 #line 712 "rx-decode.opc" 10031 int rsrc AU = (op[2] >> 4) & 0x0f; 10032 #line 712 "rx-decode.opc" 10033 int rdst AU = op[2] & 0x0f; 10034 if (trace) 10035 { 10036 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10037 "/** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */", 10038 op[0], op[1], op[2]); 10039 printf (" rsrc = 0x%x,", rsrc); 10040 printf (" rdst = 0x%x\n", rdst); 10041 } 10042 SYNTAX("rotr %1, %0"); 10043 #line 712 "rx-decode.opc" 10044 ID(rotr); SR(rsrc); DR(rdst); F__SZC; 10045 10046 } 10047 break; 10048 } 10049 break; 10050 case 0x65: 10051 GETBYTE (); 10052 switch (op[2] & 0x00) 10053 { 10054 case 0x00: 10055 { 10056 /** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */ 10057 #line 715 "rx-decode.opc" 10058 int rsrc AU = (op[2] >> 4) & 0x0f; 10059 #line 715 "rx-decode.opc" 10060 int rdst AU = op[2] & 0x0f; 10061 if (trace) 10062 { 10063 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10064 "/** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */", 10065 op[0], op[1], op[2]); 10066 printf (" rsrc = 0x%x,", rsrc); 10067 printf (" rdst = 0x%x\n", rdst); 10068 } 10069 SYNTAX("revw %1, %0"); 10070 #line 715 "rx-decode.opc" 10071 ID(revw); SR(rsrc); DR(rdst); 10072 10073 } 10074 break; 10075 } 10076 break; 10077 case 0x66: 10078 GETBYTE (); 10079 switch (op[2] & 0x00) 10080 { 10081 case 0x00: 10082 { 10083 /** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */ 10084 #line 706 "rx-decode.opc" 10085 int rsrc AU = (op[2] >> 4) & 0x0f; 10086 #line 706 "rx-decode.opc" 10087 int rdst AU = op[2] & 0x0f; 10088 if (trace) 10089 { 10090 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10091 "/** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */", 10092 op[0], op[1], op[2]); 10093 printf (" rsrc = 0x%x,", rsrc); 10094 printf (" rdst = 0x%x\n", rdst); 10095 } 10096 SYNTAX("rotl %1, %0"); 10097 #line 706 "rx-decode.opc" 10098 ID(rotl); SR(rsrc); DR(rdst); F__SZC; 10099 10100 } 10101 break; 10102 } 10103 break; 10104 case 0x67: 10105 GETBYTE (); 10106 switch (op[2] & 0x00) 10107 { 10108 case 0x00: 10109 { 10110 /** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */ 10111 #line 718 "rx-decode.opc" 10112 int rsrc AU = (op[2] >> 4) & 0x0f; 10113 #line 718 "rx-decode.opc" 10114 int rdst AU = op[2] & 0x0f; 10115 if (trace) 10116 { 10117 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10118 "/** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */", 10119 op[0], op[1], op[2]); 10120 printf (" rsrc = 0x%x,", rsrc); 10121 printf (" rdst = 0x%x\n", rdst); 10122 } 10123 SYNTAX("revl %1, %0"); 10124 #line 718 "rx-decode.opc" 10125 ID(revl); SR(rsrc); DR(rdst); 10126 10127 /*----------------------------------------------------------------------*/ 10128 /* BRANCH */ 10129 10130 } 10131 break; 10132 } 10133 break; 10134 case 0x68: 10135 GETBYTE (); 10136 switch (op[2] & 0x00) 10137 { 10138 case 0x00: 10139 op_semantics_74: 10140 { 10141 /** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */ 10142 #line 969 "rx-decode.opc" 10143 int c AU = op[1] & 0x01; 10144 #line 969 "rx-decode.opc" 10145 int rsrc AU = (op[2] >> 4) & 0x0f; 10146 #line 969 "rx-decode.opc" 10147 int rdst AU = op[2] & 0x0f; 10148 if (trace) 10149 { 10150 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10151 "/** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */", 10152 op[0], op[1], op[2]); 10153 printf (" c = 0x%x,", c); 10154 printf (" rsrc = 0x%x,", rsrc); 10155 printf (" rdst = 0x%x\n", rdst); 10156 } 10157 SYNTAX("mvtc %1, %0"); 10158 #line 969 "rx-decode.opc" 10159 ID(mov); SR(rsrc); DR(c*16+rdst + 16); 10160 10161 } 10162 break; 10163 } 10164 break; 10165 case 0x69: 10166 GETBYTE (); 10167 switch (op[2] & 0x00) 10168 { 10169 case 0x00: 10170 goto op_semantics_74; 10171 break; 10172 } 10173 break; 10174 case 0x6a: 10175 GETBYTE (); 10176 switch (op[2] & 0x00) 10177 { 10178 case 0x00: 10179 op_semantics_75: 10180 { 10181 /** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */ 10182 #line 972 "rx-decode.opc" 10183 int s AU = op[1] & 0x01; 10184 #line 972 "rx-decode.opc" 10185 int rsrc AU = (op[2] >> 4) & 0x0f; 10186 #line 972 "rx-decode.opc" 10187 int rdst AU = op[2] & 0x0f; 10188 if (trace) 10189 { 10190 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10191 "/** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */", 10192 op[0], op[1], op[2]); 10193 printf (" s = 0x%x,", s); 10194 printf (" rsrc = 0x%x,", rsrc); 10195 printf (" rdst = 0x%x\n", rdst); 10196 } 10197 SYNTAX("mvfc %1, %0"); 10198 #line 972 "rx-decode.opc" 10199 ID(mov); SR((s*16+rsrc) + 16); DR(rdst); 10200 10201 /*----------------------------------------------------------------------*/ 10202 /* INTERRUPTS */ 10203 10204 } 10205 break; 10206 } 10207 break; 10208 case 0x6b: 10209 GETBYTE (); 10210 switch (op[2] & 0x00) 10211 { 10212 case 0x00: 10213 goto op_semantics_75; 10214 break; 10215 } 10216 break; 10217 case 0x6c: 10218 GETBYTE (); 10219 switch (op[2] & 0x00) 10220 { 10221 case 0x00: 10222 op_semantics_76: 10223 { 10224 /** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */ 10225 #line 709 "rx-decode.opc" 10226 int i AU = op[1] & 0x01; 10227 #line 709 "rx-decode.opc" 10228 int mmmm AU = (op[2] >> 4) & 0x0f; 10229 #line 709 "rx-decode.opc" 10230 int rdst AU = op[2] & 0x0f; 10231 if (trace) 10232 { 10233 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10234 "/** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */", 10235 op[0], op[1], op[2]); 10236 printf (" i = 0x%x,", i); 10237 printf (" mmmm = 0x%x,", mmmm); 10238 printf (" rdst = 0x%x\n", rdst); 10239 } 10240 SYNTAX("rotr #%1, %0"); 10241 #line 709 "rx-decode.opc" 10242 ID(rotr); SC(i*16+mmmm); DR(rdst); F__SZC; 10243 10244 } 10245 break; 10246 } 10247 break; 10248 case 0x6d: 10249 GETBYTE (); 10250 switch (op[2] & 0x00) 10251 { 10252 case 0x00: 10253 goto op_semantics_76; 10254 break; 10255 } 10256 break; 10257 case 0x6e: 10258 GETBYTE (); 10259 switch (op[2] & 0x00) 10260 { 10261 case 0x00: 10262 op_semantics_77: 10263 { 10264 /** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */ 10265 #line 703 "rx-decode.opc" 10266 int i AU = op[1] & 0x01; 10267 #line 703 "rx-decode.opc" 10268 int mmmm AU = (op[2] >> 4) & 0x0f; 10269 #line 703 "rx-decode.opc" 10270 int rdst AU = op[2] & 0x0f; 10271 if (trace) 10272 { 10273 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10274 "/** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */", 10275 op[0], op[1], op[2]); 10276 printf (" i = 0x%x,", i); 10277 printf (" mmmm = 0x%x,", mmmm); 10278 printf (" rdst = 0x%x\n", rdst); 10279 } 10280 SYNTAX("rotl #%1, %0"); 10281 #line 703 "rx-decode.opc" 10282 ID(rotl); SC(i*16+mmmm); DR(rdst); F__SZC; 10283 10284 } 10285 break; 10286 } 10287 break; 10288 case 0x6f: 10289 GETBYTE (); 10290 switch (op[2] & 0x00) 10291 { 10292 case 0x00: 10293 goto op_semantics_77; 10294 break; 10295 } 10296 break; 10297 case 0x70: 10298 GETBYTE (); 10299 switch (op[2] & 0xf0) 10300 { 10301 case 0x20: 10302 op_semantics_78: 10303 { 10304 /** 1111 1101 0111 im00 0010rdst adc #%1, %0 */ 10305 #line 485 "rx-decode.opc" 10306 int im AU = (op[1] >> 2) & 0x03; 10307 #line 485 "rx-decode.opc" 10308 int rdst AU = op[2] & 0x0f; 10309 if (trace) 10310 { 10311 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10312 "/** 1111 1101 0111 im00 0010rdst adc #%1, %0 */", 10313 op[0], op[1], op[2]); 10314 printf (" im = 0x%x,", im); 10315 printf (" rdst = 0x%x\n", rdst); 10316 } 10317 SYNTAX("adc #%1, %0"); 10318 #line 485 "rx-decode.opc" 10319 ID(adc); SC(IMMex(im)); DR(rdst); F_OSZC; 10320 10321 } 10322 break; 10323 case 0x40: 10324 op_semantics_79: 10325 { 10326 /** 1111 1101 0111 im00 0100rdst max #%1, %0 */ 10327 #line 567 "rx-decode.opc" 10328 int im AU = (op[1] >> 2) & 0x03; 10329 #line 567 "rx-decode.opc" 10330 int rdst AU = op[2] & 0x0f; 10331 if (trace) 10332 { 10333 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10334 "/** 1111 1101 0111 im00 0100rdst max #%1, %0 */", 10335 op[0], op[1], op[2]); 10336 printf (" im = 0x%x,", im); 10337 printf (" rdst = 0x%x\n", rdst); 10338 } 10339 SYNTAX("max #%1, %0"); 10340 #line 567 "rx-decode.opc" 10341 ID(max); DR(rdst); SC(IMMex(im)); 10342 10343 } 10344 break; 10345 case 0x50: 10346 op_semantics_80: 10347 { 10348 /** 1111 1101 0111 im00 0101rdst min #%1, %0 */ 10349 #line 587 "rx-decode.opc" 10350 int im AU = (op[1] >> 2) & 0x03; 10351 #line 587 "rx-decode.opc" 10352 int rdst AU = op[2] & 0x0f; 10353 if (trace) 10354 { 10355 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10356 "/** 1111 1101 0111 im00 0101rdst min #%1, %0 */", 10357 op[0], op[1], op[2]); 10358 printf (" im = 0x%x,", im); 10359 printf (" rdst = 0x%x\n", rdst); 10360 } 10361 SYNTAX("min #%1, %0"); 10362 #line 587 "rx-decode.opc" 10363 ID(min); DR(rdst); SC(IMMex(im)); 10364 10365 } 10366 break; 10367 case 0x60: 10368 op_semantics_81: 10369 { 10370 /** 1111 1101 0111 im00 0110rdst emul #%1, %0 */ 10371 #line 617 "rx-decode.opc" 10372 int im AU = (op[1] >> 2) & 0x03; 10373 #line 617 "rx-decode.opc" 10374 int rdst AU = op[2] & 0x0f; 10375 if (trace) 10376 { 10377 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10378 "/** 1111 1101 0111 im00 0110rdst emul #%1, %0 */", 10379 op[0], op[1], op[2]); 10380 printf (" im = 0x%x,", im); 10381 printf (" rdst = 0x%x\n", rdst); 10382 } 10383 SYNTAX("emul #%1, %0"); 10384 #line 617 "rx-decode.opc" 10385 ID(emul); DR(rdst); SC(IMMex(im)); 10386 10387 } 10388 break; 10389 case 0x70: 10390 op_semantics_82: 10391 { 10392 /** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */ 10393 #line 629 "rx-decode.opc" 10394 int im AU = (op[1] >> 2) & 0x03; 10395 #line 629 "rx-decode.opc" 10396 int rdst AU = op[2] & 0x0f; 10397 if (trace) 10398 { 10399 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10400 "/** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */", 10401 op[0], op[1], op[2]); 10402 printf (" im = 0x%x,", im); 10403 printf (" rdst = 0x%x\n", rdst); 10404 } 10405 SYNTAX("emulu #%1, %0"); 10406 #line 629 "rx-decode.opc" 10407 ID(emulu); DR(rdst); SC(IMMex(im)); 10408 10409 } 10410 break; 10411 case 0x80: 10412 op_semantics_83: 10413 { 10414 /** 1111 1101 0111 im00 1000rdst div #%1, %0 */ 10415 #line 641 "rx-decode.opc" 10416 int im AU = (op[1] >> 2) & 0x03; 10417 #line 641 "rx-decode.opc" 10418 int rdst AU = op[2] & 0x0f; 10419 if (trace) 10420 { 10421 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10422 "/** 1111 1101 0111 im00 1000rdst div #%1, %0 */", 10423 op[0], op[1], op[2]); 10424 printf (" im = 0x%x,", im); 10425 printf (" rdst = 0x%x\n", rdst); 10426 } 10427 SYNTAX("div #%1, %0"); 10428 #line 641 "rx-decode.opc" 10429 ID(div); DR(rdst); SC(IMMex(im)); F_O___; 10430 10431 } 10432 break; 10433 case 0x90: 10434 op_semantics_84: 10435 { 10436 /** 1111 1101 0111 im00 1001rdst divu #%1, %0 */ 10437 #line 653 "rx-decode.opc" 10438 int im AU = (op[1] >> 2) & 0x03; 10439 #line 653 "rx-decode.opc" 10440 int rdst AU = op[2] & 0x0f; 10441 if (trace) 10442 { 10443 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10444 "/** 1111 1101 0111 im00 1001rdst divu #%1, %0 */", 10445 op[0], op[1], op[2]); 10446 printf (" im = 0x%x,", im); 10447 printf (" rdst = 0x%x\n", rdst); 10448 } 10449 SYNTAX("divu #%1, %0"); 10450 #line 653 "rx-decode.opc" 10451 ID(divu); DR(rdst); SC(IMMex(im)); F_O___; 10452 10453 } 10454 break; 10455 case 0xc0: 10456 op_semantics_85: 10457 { 10458 /** 1111 1101 0111 im00 1100rdst tst #%1, %2 */ 10459 #line 464 "rx-decode.opc" 10460 int im AU = (op[1] >> 2) & 0x03; 10461 #line 464 "rx-decode.opc" 10462 int rdst AU = op[2] & 0x0f; 10463 if (trace) 10464 { 10465 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10466 "/** 1111 1101 0111 im00 1100rdst tst #%1, %2 */", 10467 op[0], op[1], op[2]); 10468 printf (" im = 0x%x,", im); 10469 printf (" rdst = 0x%x\n", rdst); 10470 } 10471 SYNTAX("tst #%1, %2"); 10472 #line 464 "rx-decode.opc" 10473 ID(and); SC(IMMex(im)); S2R(rdst); F__SZ_; 10474 10475 } 10476 break; 10477 case 0xd0: 10478 op_semantics_86: 10479 { 10480 /** 1111 1101 0111 im00 1101rdst xor #%1, %0 */ 10481 #line 443 "rx-decode.opc" 10482 int im AU = (op[1] >> 2) & 0x03; 10483 #line 443 "rx-decode.opc" 10484 int rdst AU = op[2] & 0x0f; 10485 if (trace) 10486 { 10487 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10488 "/** 1111 1101 0111 im00 1101rdst xor #%1, %0 */", 10489 op[0], op[1], op[2]); 10490 printf (" im = 0x%x,", im); 10491 printf (" rdst = 0x%x\n", rdst); 10492 } 10493 SYNTAX("xor #%1, %0"); 10494 #line 443 "rx-decode.opc" 10495 ID(xor); SC(IMMex(im)); DR(rdst); F__SZ_; 10496 10497 } 10498 break; 10499 case 0xe0: 10500 op_semantics_87: 10501 { 10502 /** 1111 1101 0111 im00 1110rdst stz #%1, %0 */ 10503 #line 389 "rx-decode.opc" 10504 int im AU = (op[1] >> 2) & 0x03; 10505 #line 389 "rx-decode.opc" 10506 int rdst AU = op[2] & 0x0f; 10507 if (trace) 10508 { 10509 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10510 "/** 1111 1101 0111 im00 1110rdst stz #%1, %0 */", 10511 op[0], op[1], op[2]); 10512 printf (" im = 0x%x,", im); 10513 printf (" rdst = 0x%x\n", rdst); 10514 } 10515 SYNTAX("stz #%1, %0"); 10516 #line 389 "rx-decode.opc" 10517 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z); 10518 10519 } 10520 break; 10521 case 0xf0: 10522 op_semantics_88: 10523 { 10524 /** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */ 10525 #line 392 "rx-decode.opc" 10526 int im AU = (op[1] >> 2) & 0x03; 10527 #line 392 "rx-decode.opc" 10528 int rdst AU = op[2] & 0x0f; 10529 if (trace) 10530 { 10531 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10532 "/** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */", 10533 op[0], op[1], op[2]); 10534 printf (" im = 0x%x,", im); 10535 printf (" rdst = 0x%x\n", rdst); 10536 } 10537 SYNTAX("stnz #%1, %0"); 10538 #line 392 "rx-decode.opc" 10539 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz); 10540 10541 /*----------------------------------------------------------------------*/ 10542 /* RTSD */ 10543 10544 } 10545 break; 10546 default: UNSUPPORTED(); break; 10547 } 10548 break; 10549 case 0x72: 10550 GETBYTE (); 10551 switch (op[2] & 0xf0) 10552 { 10553 case 0x00: 10554 { 10555 /** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */ 10556 #line 861 "rx-decode.opc" 10557 int rdst AU = op[2] & 0x0f; 10558 if (trace) 10559 { 10560 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10561 "/** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */", 10562 op[0], op[1], op[2]); 10563 printf (" rdst = 0x%x\n", rdst); 10564 } 10565 SYNTAX("fsub #%1, %0"); 10566 #line 861 "rx-decode.opc" 10567 ID(fsub); DR(rdst); SC(IMM(0)); F__SZ_; 10568 10569 } 10570 break; 10571 case 0x10: 10572 { 10573 /** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */ 10574 #line 855 "rx-decode.opc" 10575 int rdst AU = op[2] & 0x0f; 10576 if (trace) 10577 { 10578 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10579 "/** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */", 10580 op[0], op[1], op[2]); 10581 printf (" rdst = 0x%x\n", rdst); 10582 } 10583 SYNTAX("fcmp #%1, %0"); 10584 #line 855 "rx-decode.opc" 10585 ID(fcmp); DR(rdst); SC(IMM(0)); F_OSZ_; 10586 10587 } 10588 break; 10589 case 0x20: 10590 { 10591 /** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */ 10592 #line 849 "rx-decode.opc" 10593 int rdst AU = op[2] & 0x0f; 10594 if (trace) 10595 { 10596 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10597 "/** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */", 10598 op[0], op[1], op[2]); 10599 printf (" rdst = 0x%x\n", rdst); 10600 } 10601 SYNTAX("fadd #%1, %0"); 10602 #line 849 "rx-decode.opc" 10603 ID(fadd); DR(rdst); SC(IMM(0)); F__SZ_; 10604 10605 } 10606 break; 10607 case 0x30: 10608 { 10609 /** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */ 10610 #line 870 "rx-decode.opc" 10611 int rdst AU = op[2] & 0x0f; 10612 if (trace) 10613 { 10614 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10615 "/** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */", 10616 op[0], op[1], op[2]); 10617 printf (" rdst = 0x%x\n", rdst); 10618 } 10619 SYNTAX("fmul #%1, %0"); 10620 #line 870 "rx-decode.opc" 10621 ID(fmul); DR(rdst); SC(IMM(0)); F__SZ_; 10622 10623 } 10624 break; 10625 case 0x40: 10626 { 10627 /** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */ 10628 #line 876 "rx-decode.opc" 10629 int rdst AU = op[2] & 0x0f; 10630 if (trace) 10631 { 10632 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10633 "/** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */", 10634 op[0], op[1], op[2]); 10635 printf (" rdst = 0x%x\n", rdst); 10636 } 10637 SYNTAX("fdiv #%1, %0"); 10638 #line 876 "rx-decode.opc" 10639 ID(fdiv); DR(rdst); SC(IMM(0)); F__SZ_; 10640 10641 } 10642 break; 10643 default: UNSUPPORTED(); break; 10644 } 10645 break; 10646 case 0x73: 10647 GETBYTE (); 10648 switch (op[2] & 0xe0) 10649 { 10650 case 0x00: 10651 op_semantics_89: 10652 { 10653 /** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */ 10654 #line 966 "rx-decode.opc" 10655 int im AU = (op[1] >> 2) & 0x03; 10656 #line 966 "rx-decode.opc" 10657 int crdst AU = op[2] & 0x1f; 10658 if (trace) 10659 { 10660 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10661 "/** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */", 10662 op[0], op[1], op[2]); 10663 printf (" im = 0x%x,", im); 10664 printf (" crdst = 0x%x\n", crdst); 10665 } 10666 SYNTAX("mvtc #%1, %0"); 10667 #line 966 "rx-decode.opc" 10668 ID(mov); SC(IMMex(im)); DR(crdst + 16); 10669 10670 } 10671 break; 10672 default: UNSUPPORTED(); break; 10673 } 10674 break; 10675 case 0x74: 10676 GETBYTE (); 10677 switch (op[2] & 0xf0) 10678 { 10679 case 0x20: 10680 goto op_semantics_78; 10681 break; 10682 case 0x40: 10683 goto op_semantics_79; 10684 break; 10685 case 0x50: 10686 goto op_semantics_80; 10687 break; 10688 case 0x60: 10689 goto op_semantics_81; 10690 break; 10691 case 0x70: 10692 goto op_semantics_82; 10693 break; 10694 case 0x80: 10695 goto op_semantics_83; 10696 break; 10697 case 0x90: 10698 goto op_semantics_84; 10699 break; 10700 case 0xc0: 10701 goto op_semantics_85; 10702 break; 10703 case 0xd0: 10704 goto op_semantics_86; 10705 break; 10706 case 0xe0: 10707 goto op_semantics_87; 10708 break; 10709 case 0xf0: 10710 goto op_semantics_88; 10711 break; 10712 default: UNSUPPORTED(); break; 10713 } 10714 break; 10715 case 0x77: 10716 GETBYTE (); 10717 switch (op[2] & 0xe0) 10718 { 10719 case 0x00: 10720 goto op_semantics_89; 10721 break; 10722 default: UNSUPPORTED(); break; 10723 } 10724 break; 10725 case 0x78: 10726 GETBYTE (); 10727 switch (op[2] & 0xf0) 10728 { 10729 case 0x20: 10730 goto op_semantics_78; 10731 break; 10732 case 0x40: 10733 goto op_semantics_79; 10734 break; 10735 case 0x50: 10736 goto op_semantics_80; 10737 break; 10738 case 0x60: 10739 goto op_semantics_81; 10740 break; 10741 case 0x70: 10742 goto op_semantics_82; 10743 break; 10744 case 0x80: 10745 goto op_semantics_83; 10746 break; 10747 case 0x90: 10748 goto op_semantics_84; 10749 break; 10750 case 0xc0: 10751 goto op_semantics_85; 10752 break; 10753 case 0xd0: 10754 goto op_semantics_86; 10755 break; 10756 case 0xe0: 10757 goto op_semantics_87; 10758 break; 10759 case 0xf0: 10760 goto op_semantics_88; 10761 break; 10762 default: UNSUPPORTED(); break; 10763 } 10764 break; 10765 case 0x7b: 10766 GETBYTE (); 10767 switch (op[2] & 0xe0) 10768 { 10769 case 0x00: 10770 goto op_semantics_89; 10771 break; 10772 default: UNSUPPORTED(); break; 10773 } 10774 break; 10775 case 0x7c: 10776 GETBYTE (); 10777 switch (op[2] & 0xf0) 10778 { 10779 case 0x20: 10780 goto op_semantics_78; 10781 break; 10782 case 0x40: 10783 goto op_semantics_79; 10784 break; 10785 case 0x50: 10786 goto op_semantics_80; 10787 break; 10788 case 0x60: 10789 goto op_semantics_81; 10790 break; 10791 case 0x70: 10792 goto op_semantics_82; 10793 break; 10794 case 0x80: 10795 goto op_semantics_83; 10796 break; 10797 case 0x90: 10798 goto op_semantics_84; 10799 break; 10800 case 0xc0: 10801 goto op_semantics_85; 10802 break; 10803 case 0xd0: 10804 goto op_semantics_86; 10805 break; 10806 case 0xe0: 10807 goto op_semantics_87; 10808 break; 10809 case 0xf0: 10810 goto op_semantics_88; 10811 break; 10812 default: UNSUPPORTED(); break; 10813 } 10814 break; 10815 case 0x7f: 10816 GETBYTE (); 10817 switch (op[2] & 0xe0) 10818 { 10819 case 0x00: 10820 goto op_semantics_89; 10821 break; 10822 default: UNSUPPORTED(); break; 10823 } 10824 break; 10825 case 0x80: 10826 GETBYTE (); 10827 switch (op[2] & 0x00) 10828 { 10829 case 0x00: 10830 op_semantics_90: 10831 { 10832 /** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */ 10833 #line 691 "rx-decode.opc" 10834 int immmm AU = op[1] & 0x1f; 10835 #line 691 "rx-decode.opc" 10836 int rsrc AU = (op[2] >> 4) & 0x0f; 10837 #line 691 "rx-decode.opc" 10838 int rdst AU = op[2] & 0x0f; 10839 if (trace) 10840 { 10841 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10842 "/** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */", 10843 op[0], op[1], op[2]); 10844 printf (" immmm = 0x%x,", immmm); 10845 printf (" rsrc = 0x%x,", rsrc); 10846 printf (" rdst = 0x%x\n", rdst); 10847 } 10848 SYNTAX("shlr #%2, %1, %0"); 10849 #line 691 "rx-decode.opc" 10850 ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F__SZC; 10851 10852 /*----------------------------------------------------------------------*/ 10853 /* ROTATE */ 10854 10855 } 10856 break; 10857 } 10858 break; 10859 case 0x81: 10860 GETBYTE (); 10861 switch (op[2] & 0x00) 10862 { 10863 case 0x00: 10864 goto op_semantics_90; 10865 break; 10866 } 10867 break; 10868 case 0x82: 10869 GETBYTE (); 10870 switch (op[2] & 0x00) 10871 { 10872 case 0x00: 10873 goto op_semantics_90; 10874 break; 10875 } 10876 break; 10877 case 0x83: 10878 GETBYTE (); 10879 switch (op[2] & 0x00) 10880 { 10881 case 0x00: 10882 goto op_semantics_90; 10883 break; 10884 } 10885 break; 10886 case 0x84: 10887 GETBYTE (); 10888 switch (op[2] & 0x00) 10889 { 10890 case 0x00: 10891 goto op_semantics_90; 10892 break; 10893 } 10894 break; 10895 case 0x85: 10896 GETBYTE (); 10897 switch (op[2] & 0x00) 10898 { 10899 case 0x00: 10900 goto op_semantics_90; 10901 break; 10902 } 10903 break; 10904 case 0x86: 10905 GETBYTE (); 10906 switch (op[2] & 0x00) 10907 { 10908 case 0x00: 10909 goto op_semantics_90; 10910 break; 10911 } 10912 break; 10913 case 0x87: 10914 GETBYTE (); 10915 switch (op[2] & 0x00) 10916 { 10917 case 0x00: 10918 goto op_semantics_90; 10919 break; 10920 } 10921 break; 10922 case 0x88: 10923 GETBYTE (); 10924 switch (op[2] & 0x00) 10925 { 10926 case 0x00: 10927 goto op_semantics_90; 10928 break; 10929 } 10930 break; 10931 case 0x89: 10932 GETBYTE (); 10933 switch (op[2] & 0x00) 10934 { 10935 case 0x00: 10936 goto op_semantics_90; 10937 break; 10938 } 10939 break; 10940 case 0x8a: 10941 GETBYTE (); 10942 switch (op[2] & 0x00) 10943 { 10944 case 0x00: 10945 goto op_semantics_90; 10946 break; 10947 } 10948 break; 10949 case 0x8b: 10950 GETBYTE (); 10951 switch (op[2] & 0x00) 10952 { 10953 case 0x00: 10954 goto op_semantics_90; 10955 break; 10956 } 10957 break; 10958 case 0x8c: 10959 GETBYTE (); 10960 switch (op[2] & 0x00) 10961 { 10962 case 0x00: 10963 goto op_semantics_90; 10964 break; 10965 } 10966 break; 10967 case 0x8d: 10968 GETBYTE (); 10969 switch (op[2] & 0x00) 10970 { 10971 case 0x00: 10972 goto op_semantics_90; 10973 break; 10974 } 10975 break; 10976 case 0x8e: 10977 GETBYTE (); 10978 switch (op[2] & 0x00) 10979 { 10980 case 0x00: 10981 goto op_semantics_90; 10982 break; 10983 } 10984 break; 10985 case 0x8f: 10986 GETBYTE (); 10987 switch (op[2] & 0x00) 10988 { 10989 case 0x00: 10990 goto op_semantics_90; 10991 break; 10992 } 10993 break; 10994 case 0x90: 10995 GETBYTE (); 10996 switch (op[2] & 0x00) 10997 { 10998 case 0x00: 10999 goto op_semantics_90; 11000 break; 11001 } 11002 break; 11003 case 0x91: 11004 GETBYTE (); 11005 switch (op[2] & 0x00) 11006 { 11007 case 0x00: 11008 goto op_semantics_90; 11009 break; 11010 } 11011 break; 11012 case 0x92: 11013 GETBYTE (); 11014 switch (op[2] & 0x00) 11015 { 11016 case 0x00: 11017 goto op_semantics_90; 11018 break; 11019 } 11020 break; 11021 case 0x93: 11022 GETBYTE (); 11023 switch (op[2] & 0x00) 11024 { 11025 case 0x00: 11026 goto op_semantics_90; 11027 break; 11028 } 11029 break; 11030 case 0x94: 11031 GETBYTE (); 11032 switch (op[2] & 0x00) 11033 { 11034 case 0x00: 11035 goto op_semantics_90; 11036 break; 11037 } 11038 break; 11039 case 0x95: 11040 GETBYTE (); 11041 switch (op[2] & 0x00) 11042 { 11043 case 0x00: 11044 goto op_semantics_90; 11045 break; 11046 } 11047 break; 11048 case 0x96: 11049 GETBYTE (); 11050 switch (op[2] & 0x00) 11051 { 11052 case 0x00: 11053 goto op_semantics_90; 11054 break; 11055 } 11056 break; 11057 case 0x97: 11058 GETBYTE (); 11059 switch (op[2] & 0x00) 11060 { 11061 case 0x00: 11062 goto op_semantics_90; 11063 break; 11064 } 11065 break; 11066 case 0x98: 11067 GETBYTE (); 11068 switch (op[2] & 0x00) 11069 { 11070 case 0x00: 11071 goto op_semantics_90; 11072 break; 11073 } 11074 break; 11075 case 0x99: 11076 GETBYTE (); 11077 switch (op[2] & 0x00) 11078 { 11079 case 0x00: 11080 goto op_semantics_90; 11081 break; 11082 } 11083 break; 11084 case 0x9a: 11085 GETBYTE (); 11086 switch (op[2] & 0x00) 11087 { 11088 case 0x00: 11089 goto op_semantics_90; 11090 break; 11091 } 11092 break; 11093 case 0x9b: 11094 GETBYTE (); 11095 switch (op[2] & 0x00) 11096 { 11097 case 0x00: 11098 goto op_semantics_90; 11099 break; 11100 } 11101 break; 11102 case 0x9c: 11103 GETBYTE (); 11104 switch (op[2] & 0x00) 11105 { 11106 case 0x00: 11107 goto op_semantics_90; 11108 break; 11109 } 11110 break; 11111 case 0x9d: 11112 GETBYTE (); 11113 switch (op[2] & 0x00) 11114 { 11115 case 0x00: 11116 goto op_semantics_90; 11117 break; 11118 } 11119 break; 11120 case 0x9e: 11121 GETBYTE (); 11122 switch (op[2] & 0x00) 11123 { 11124 case 0x00: 11125 goto op_semantics_90; 11126 break; 11127 } 11128 break; 11129 case 0x9f: 11130 GETBYTE (); 11131 switch (op[2] & 0x00) 11132 { 11133 case 0x00: 11134 goto op_semantics_90; 11135 break; 11136 } 11137 break; 11138 case 0xa0: 11139 GETBYTE (); 11140 switch (op[2] & 0x00) 11141 { 11142 case 0x00: 11143 op_semantics_91: 11144 { 11145 /** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */ 11146 #line 681 "rx-decode.opc" 11147 int immmm AU = op[1] & 0x1f; 11148 #line 681 "rx-decode.opc" 11149 int rsrc AU = (op[2] >> 4) & 0x0f; 11150 #line 681 "rx-decode.opc" 11151 int rdst AU = op[2] & 0x0f; 11152 if (trace) 11153 { 11154 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11155 "/** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */", 11156 op[0], op[1], op[2]); 11157 printf (" immmm = 0x%x,", immmm); 11158 printf (" rsrc = 0x%x,", rsrc); 11159 printf (" rdst = 0x%x\n", rdst); 11160 } 11161 SYNTAX("shar #%2, %1, %0"); 11162 #line 681 "rx-decode.opc" 11163 ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F_0SZC; 11164 11165 11166 } 11167 break; 11168 } 11169 break; 11170 case 0xa1: 11171 GETBYTE (); 11172 switch (op[2] & 0x00) 11173 { 11174 case 0x00: 11175 goto op_semantics_91; 11176 break; 11177 } 11178 break; 11179 case 0xa2: 11180 GETBYTE (); 11181 switch (op[2] & 0x00) 11182 { 11183 case 0x00: 11184 goto op_semantics_91; 11185 break; 11186 } 11187 break; 11188 case 0xa3: 11189 GETBYTE (); 11190 switch (op[2] & 0x00) 11191 { 11192 case 0x00: 11193 goto op_semantics_91; 11194 break; 11195 } 11196 break; 11197 case 0xa4: 11198 GETBYTE (); 11199 switch (op[2] & 0x00) 11200 { 11201 case 0x00: 11202 goto op_semantics_91; 11203 break; 11204 } 11205 break; 11206 case 0xa5: 11207 GETBYTE (); 11208 switch (op[2] & 0x00) 11209 { 11210 case 0x00: 11211 goto op_semantics_91; 11212 break; 11213 } 11214 break; 11215 case 0xa6: 11216 GETBYTE (); 11217 switch (op[2] & 0x00) 11218 { 11219 case 0x00: 11220 goto op_semantics_91; 11221 break; 11222 } 11223 break; 11224 case 0xa7: 11225 GETBYTE (); 11226 switch (op[2] & 0x00) 11227 { 11228 case 0x00: 11229 goto op_semantics_91; 11230 break; 11231 } 11232 break; 11233 case 0xa8: 11234 GETBYTE (); 11235 switch (op[2] & 0x00) 11236 { 11237 case 0x00: 11238 goto op_semantics_91; 11239 break; 11240 } 11241 break; 11242 case 0xa9: 11243 GETBYTE (); 11244 switch (op[2] & 0x00) 11245 { 11246 case 0x00: 11247 goto op_semantics_91; 11248 break; 11249 } 11250 break; 11251 case 0xaa: 11252 GETBYTE (); 11253 switch (op[2] & 0x00) 11254 { 11255 case 0x00: 11256 goto op_semantics_91; 11257 break; 11258 } 11259 break; 11260 case 0xab: 11261 GETBYTE (); 11262 switch (op[2] & 0x00) 11263 { 11264 case 0x00: 11265 goto op_semantics_91; 11266 break; 11267 } 11268 break; 11269 case 0xac: 11270 GETBYTE (); 11271 switch (op[2] & 0x00) 11272 { 11273 case 0x00: 11274 goto op_semantics_91; 11275 break; 11276 } 11277 break; 11278 case 0xad: 11279 GETBYTE (); 11280 switch (op[2] & 0x00) 11281 { 11282 case 0x00: 11283 goto op_semantics_91; 11284 break; 11285 } 11286 break; 11287 case 0xae: 11288 GETBYTE (); 11289 switch (op[2] & 0x00) 11290 { 11291 case 0x00: 11292 goto op_semantics_91; 11293 break; 11294 } 11295 break; 11296 case 0xaf: 11297 GETBYTE (); 11298 switch (op[2] & 0x00) 11299 { 11300 case 0x00: 11301 goto op_semantics_91; 11302 break; 11303 } 11304 break; 11305 case 0xb0: 11306 GETBYTE (); 11307 switch (op[2] & 0x00) 11308 { 11309 case 0x00: 11310 goto op_semantics_91; 11311 break; 11312 } 11313 break; 11314 case 0xb1: 11315 GETBYTE (); 11316 switch (op[2] & 0x00) 11317 { 11318 case 0x00: 11319 goto op_semantics_91; 11320 break; 11321 } 11322 break; 11323 case 0xb2: 11324 GETBYTE (); 11325 switch (op[2] & 0x00) 11326 { 11327 case 0x00: 11328 goto op_semantics_91; 11329 break; 11330 } 11331 break; 11332 case 0xb3: 11333 GETBYTE (); 11334 switch (op[2] & 0x00) 11335 { 11336 case 0x00: 11337 goto op_semantics_91; 11338 break; 11339 } 11340 break; 11341 case 0xb4: 11342 GETBYTE (); 11343 switch (op[2] & 0x00) 11344 { 11345 case 0x00: 11346 goto op_semantics_91; 11347 break; 11348 } 11349 break; 11350 case 0xb5: 11351 GETBYTE (); 11352 switch (op[2] & 0x00) 11353 { 11354 case 0x00: 11355 goto op_semantics_91; 11356 break; 11357 } 11358 break; 11359 case 0xb6: 11360 GETBYTE (); 11361 switch (op[2] & 0x00) 11362 { 11363 case 0x00: 11364 goto op_semantics_91; 11365 break; 11366 } 11367 break; 11368 case 0xb7: 11369 GETBYTE (); 11370 switch (op[2] & 0x00) 11371 { 11372 case 0x00: 11373 goto op_semantics_91; 11374 break; 11375 } 11376 break; 11377 case 0xb8: 11378 GETBYTE (); 11379 switch (op[2] & 0x00) 11380 { 11381 case 0x00: 11382 goto op_semantics_91; 11383 break; 11384 } 11385 break; 11386 case 0xb9: 11387 GETBYTE (); 11388 switch (op[2] & 0x00) 11389 { 11390 case 0x00: 11391 goto op_semantics_91; 11392 break; 11393 } 11394 break; 11395 case 0xba: 11396 GETBYTE (); 11397 switch (op[2] & 0x00) 11398 { 11399 case 0x00: 11400 goto op_semantics_91; 11401 break; 11402 } 11403 break; 11404 case 0xbb: 11405 GETBYTE (); 11406 switch (op[2] & 0x00) 11407 { 11408 case 0x00: 11409 goto op_semantics_91; 11410 break; 11411 } 11412 break; 11413 case 0xbc: 11414 GETBYTE (); 11415 switch (op[2] & 0x00) 11416 { 11417 case 0x00: 11418 goto op_semantics_91; 11419 break; 11420 } 11421 break; 11422 case 0xbd: 11423 GETBYTE (); 11424 switch (op[2] & 0x00) 11425 { 11426 case 0x00: 11427 goto op_semantics_91; 11428 break; 11429 } 11430 break; 11431 case 0xbe: 11432 GETBYTE (); 11433 switch (op[2] & 0x00) 11434 { 11435 case 0x00: 11436 goto op_semantics_91; 11437 break; 11438 } 11439 break; 11440 case 0xbf: 11441 GETBYTE (); 11442 switch (op[2] & 0x00) 11443 { 11444 case 0x00: 11445 goto op_semantics_91; 11446 break; 11447 } 11448 break; 11449 case 0xc0: 11450 GETBYTE (); 11451 switch (op[2] & 0x00) 11452 { 11453 case 0x00: 11454 op_semantics_92: 11455 { 11456 /** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */ 11457 #line 671 "rx-decode.opc" 11458 int immmm AU = op[1] & 0x1f; 11459 #line 671 "rx-decode.opc" 11460 int rsrc AU = (op[2] >> 4) & 0x0f; 11461 #line 671 "rx-decode.opc" 11462 int rdst AU = op[2] & 0x0f; 11463 if (trace) 11464 { 11465 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11466 "/** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */", 11467 op[0], op[1], op[2]); 11468 printf (" immmm = 0x%x,", immmm); 11469 printf (" rsrc = 0x%x,", rsrc); 11470 printf (" rdst = 0x%x\n", rdst); 11471 } 11472 SYNTAX("shll #%2, %1, %0"); 11473 #line 671 "rx-decode.opc" 11474 ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F_OSZC; 11475 11476 11477 } 11478 break; 11479 } 11480 break; 11481 case 0xc1: 11482 GETBYTE (); 11483 switch (op[2] & 0x00) 11484 { 11485 case 0x00: 11486 goto op_semantics_92; 11487 break; 11488 } 11489 break; 11490 case 0xc2: 11491 GETBYTE (); 11492 switch (op[2] & 0x00) 11493 { 11494 case 0x00: 11495 goto op_semantics_92; 11496 break; 11497 } 11498 break; 11499 case 0xc3: 11500 GETBYTE (); 11501 switch (op[2] & 0x00) 11502 { 11503 case 0x00: 11504 goto op_semantics_92; 11505 break; 11506 } 11507 break; 11508 case 0xc4: 11509 GETBYTE (); 11510 switch (op[2] & 0x00) 11511 { 11512 case 0x00: 11513 goto op_semantics_92; 11514 break; 11515 } 11516 break; 11517 case 0xc5: 11518 GETBYTE (); 11519 switch (op[2] & 0x00) 11520 { 11521 case 0x00: 11522 goto op_semantics_92; 11523 break; 11524 } 11525 break; 11526 case 0xc6: 11527 GETBYTE (); 11528 switch (op[2] & 0x00) 11529 { 11530 case 0x00: 11531 goto op_semantics_92; 11532 break; 11533 } 11534 break; 11535 case 0xc7: 11536 GETBYTE (); 11537 switch (op[2] & 0x00) 11538 { 11539 case 0x00: 11540 goto op_semantics_92; 11541 break; 11542 } 11543 break; 11544 case 0xc8: 11545 GETBYTE (); 11546 switch (op[2] & 0x00) 11547 { 11548 case 0x00: 11549 goto op_semantics_92; 11550 break; 11551 } 11552 break; 11553 case 0xc9: 11554 GETBYTE (); 11555 switch (op[2] & 0x00) 11556 { 11557 case 0x00: 11558 goto op_semantics_92; 11559 break; 11560 } 11561 break; 11562 case 0xca: 11563 GETBYTE (); 11564 switch (op[2] & 0x00) 11565 { 11566 case 0x00: 11567 goto op_semantics_92; 11568 break; 11569 } 11570 break; 11571 case 0xcb: 11572 GETBYTE (); 11573 switch (op[2] & 0x00) 11574 { 11575 case 0x00: 11576 goto op_semantics_92; 11577 break; 11578 } 11579 break; 11580 case 0xcc: 11581 GETBYTE (); 11582 switch (op[2] & 0x00) 11583 { 11584 case 0x00: 11585 goto op_semantics_92; 11586 break; 11587 } 11588 break; 11589 case 0xcd: 11590 GETBYTE (); 11591 switch (op[2] & 0x00) 11592 { 11593 case 0x00: 11594 goto op_semantics_92; 11595 break; 11596 } 11597 break; 11598 case 0xce: 11599 GETBYTE (); 11600 switch (op[2] & 0x00) 11601 { 11602 case 0x00: 11603 goto op_semantics_92; 11604 break; 11605 } 11606 break; 11607 case 0xcf: 11608 GETBYTE (); 11609 switch (op[2] & 0x00) 11610 { 11611 case 0x00: 11612 goto op_semantics_92; 11613 break; 11614 } 11615 break; 11616 case 0xd0: 11617 GETBYTE (); 11618 switch (op[2] & 0x00) 11619 { 11620 case 0x00: 11621 goto op_semantics_92; 11622 break; 11623 } 11624 break; 11625 case 0xd1: 11626 GETBYTE (); 11627 switch (op[2] & 0x00) 11628 { 11629 case 0x00: 11630 goto op_semantics_92; 11631 break; 11632 } 11633 break; 11634 case 0xd2: 11635 GETBYTE (); 11636 switch (op[2] & 0x00) 11637 { 11638 case 0x00: 11639 goto op_semantics_92; 11640 break; 11641 } 11642 break; 11643 case 0xd3: 11644 GETBYTE (); 11645 switch (op[2] & 0x00) 11646 { 11647 case 0x00: 11648 goto op_semantics_92; 11649 break; 11650 } 11651 break; 11652 case 0xd4: 11653 GETBYTE (); 11654 switch (op[2] & 0x00) 11655 { 11656 case 0x00: 11657 goto op_semantics_92; 11658 break; 11659 } 11660 break; 11661 case 0xd5: 11662 GETBYTE (); 11663 switch (op[2] & 0x00) 11664 { 11665 case 0x00: 11666 goto op_semantics_92; 11667 break; 11668 } 11669 break; 11670 case 0xd6: 11671 GETBYTE (); 11672 switch (op[2] & 0x00) 11673 { 11674 case 0x00: 11675 goto op_semantics_92; 11676 break; 11677 } 11678 break; 11679 case 0xd7: 11680 GETBYTE (); 11681 switch (op[2] & 0x00) 11682 { 11683 case 0x00: 11684 goto op_semantics_92; 11685 break; 11686 } 11687 break; 11688 case 0xd8: 11689 GETBYTE (); 11690 switch (op[2] & 0x00) 11691 { 11692 case 0x00: 11693 goto op_semantics_92; 11694 break; 11695 } 11696 break; 11697 case 0xd9: 11698 GETBYTE (); 11699 switch (op[2] & 0x00) 11700 { 11701 case 0x00: 11702 goto op_semantics_92; 11703 break; 11704 } 11705 break; 11706 case 0xda: 11707 GETBYTE (); 11708 switch (op[2] & 0x00) 11709 { 11710 case 0x00: 11711 goto op_semantics_92; 11712 break; 11713 } 11714 break; 11715 case 0xdb: 11716 GETBYTE (); 11717 switch (op[2] & 0x00) 11718 { 11719 case 0x00: 11720 goto op_semantics_92; 11721 break; 11722 } 11723 break; 11724 case 0xdc: 11725 GETBYTE (); 11726 switch (op[2] & 0x00) 11727 { 11728 case 0x00: 11729 goto op_semantics_92; 11730 break; 11731 } 11732 break; 11733 case 0xdd: 11734 GETBYTE (); 11735 switch (op[2] & 0x00) 11736 { 11737 case 0x00: 11738 goto op_semantics_92; 11739 break; 11740 } 11741 break; 11742 case 0xde: 11743 GETBYTE (); 11744 switch (op[2] & 0x00) 11745 { 11746 case 0x00: 11747 goto op_semantics_92; 11748 break; 11749 } 11750 break; 11751 case 0xdf: 11752 GETBYTE (); 11753 switch (op[2] & 0x00) 11754 { 11755 case 0x00: 11756 goto op_semantics_92; 11757 break; 11758 } 11759 break; 11760 case 0xe0: 11761 GETBYTE (); 11762 switch (op[2] & 0xf0) 11763 { 11764 case 0x00: 11765 case 0x10: 11766 case 0x20: 11767 case 0x30: 11768 case 0x40: 11769 case 0x50: 11770 case 0x60: 11771 case 0x70: 11772 case 0x80: 11773 case 0x90: 11774 case 0xa0: 11775 case 0xb0: 11776 case 0xc0: 11777 case 0xd0: 11778 case 0xe0: 11779 op_semantics_93: 11780 { 11781 /** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */ 11782 #line 945 "rx-decode.opc" 11783 int bittt AU = op[1] & 0x1f; 11784 #line 945 "rx-decode.opc" 11785 int cond AU = (op[2] >> 4) & 0x0f; 11786 #line 945 "rx-decode.opc" 11787 int rdst AU = op[2] & 0x0f; 11788 if (trace) 11789 { 11790 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11791 "/** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */", 11792 op[0], op[1], op[2]); 11793 printf (" bittt = 0x%x,", bittt); 11794 printf (" cond = 0x%x,", cond); 11795 printf (" rdst = 0x%x\n", rdst); 11796 } 11797 SYNTAX("bm%2 #%1, %0%S0"); 11798 #line 945 "rx-decode.opc" 11799 ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst); 11800 11801 /*----------------------------------------------------------------------*/ 11802 /* CONTROL REGISTERS */ 11803 11804 } 11805 break; 11806 case 0xf0: 11807 op_semantics_94: 11808 { 11809 /** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */ 11810 #line 938 "rx-decode.opc" 11811 int bittt AU = op[1] & 0x1f; 11812 #line 938 "rx-decode.opc" 11813 int rdst AU = op[2] & 0x0f; 11814 if (trace) 11815 { 11816 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11817 "/** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */", 11818 op[0], op[1], op[2]); 11819 printf (" bittt = 0x%x,", bittt); 11820 printf (" rdst = 0x%x\n", rdst); 11821 } 11822 SYNTAX("bnot #%1, %0"); 11823 #line 938 "rx-decode.opc" 11824 ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst); 11825 11826 11827 } 11828 break; 11829 } 11830 break; 11831 case 0xe1: 11832 GETBYTE (); 11833 switch (op[2] & 0xf0) 11834 { 11835 case 0x00: 11836 case 0x10: 11837 case 0x20: 11838 case 0x30: 11839 case 0x40: 11840 case 0x50: 11841 case 0x60: 11842 case 0x70: 11843 case 0x80: 11844 case 0x90: 11845 case 0xa0: 11846 case 0xb0: 11847 case 0xc0: 11848 case 0xd0: 11849 case 0xe0: 11850 goto op_semantics_93; 11851 break; 11852 case 0xf0: 11853 goto op_semantics_94; 11854 break; 11855 } 11856 break; 11857 case 0xe2: 11858 GETBYTE (); 11859 switch (op[2] & 0xf0) 11860 { 11861 case 0x00: 11862 case 0x10: 11863 case 0x20: 11864 case 0x30: 11865 case 0x40: 11866 case 0x50: 11867 case 0x60: 11868 case 0x70: 11869 case 0x80: 11870 case 0x90: 11871 case 0xa0: 11872 case 0xb0: 11873 case 0xc0: 11874 case 0xd0: 11875 case 0xe0: 11876 goto op_semantics_93; 11877 break; 11878 case 0xf0: 11879 goto op_semantics_94; 11880 break; 11881 } 11882 break; 11883 case 0xe3: 11884 GETBYTE (); 11885 switch (op[2] & 0xf0) 11886 { 11887 case 0x00: 11888 case 0x10: 11889 case 0x20: 11890 case 0x30: 11891 case 0x40: 11892 case 0x50: 11893 case 0x60: 11894 case 0x70: 11895 case 0x80: 11896 case 0x90: 11897 case 0xa0: 11898 case 0xb0: 11899 case 0xc0: 11900 case 0xd0: 11901 case 0xe0: 11902 goto op_semantics_93; 11903 break; 11904 case 0xf0: 11905 goto op_semantics_94; 11906 break; 11907 } 11908 break; 11909 case 0xe4: 11910 GETBYTE (); 11911 switch (op[2] & 0xf0) 11912 { 11913 case 0x00: 11914 case 0x10: 11915 case 0x20: 11916 case 0x30: 11917 case 0x40: 11918 case 0x50: 11919 case 0x60: 11920 case 0x70: 11921 case 0x80: 11922 case 0x90: 11923 case 0xa0: 11924 case 0xb0: 11925 case 0xc0: 11926 case 0xd0: 11927 case 0xe0: 11928 goto op_semantics_93; 11929 break; 11930 case 0xf0: 11931 goto op_semantics_94; 11932 break; 11933 } 11934 break; 11935 case 0xe5: 11936 GETBYTE (); 11937 switch (op[2] & 0xf0) 11938 { 11939 case 0x00: 11940 case 0x10: 11941 case 0x20: 11942 case 0x30: 11943 case 0x40: 11944 case 0x50: 11945 case 0x60: 11946 case 0x70: 11947 case 0x80: 11948 case 0x90: 11949 case 0xa0: 11950 case 0xb0: 11951 case 0xc0: 11952 case 0xd0: 11953 case 0xe0: 11954 goto op_semantics_93; 11955 break; 11956 case 0xf0: 11957 goto op_semantics_94; 11958 break; 11959 } 11960 break; 11961 case 0xe6: 11962 GETBYTE (); 11963 switch (op[2] & 0xf0) 11964 { 11965 case 0x00: 11966 case 0x10: 11967 case 0x20: 11968 case 0x30: 11969 case 0x40: 11970 case 0x50: 11971 case 0x60: 11972 case 0x70: 11973 case 0x80: 11974 case 0x90: 11975 case 0xa0: 11976 case 0xb0: 11977 case 0xc0: 11978 case 0xd0: 11979 case 0xe0: 11980 goto op_semantics_93; 11981 break; 11982 case 0xf0: 11983 goto op_semantics_94; 11984 break; 11985 } 11986 break; 11987 case 0xe7: 11988 GETBYTE (); 11989 switch (op[2] & 0xf0) 11990 { 11991 case 0x00: 11992 case 0x10: 11993 case 0x20: 11994 case 0x30: 11995 case 0x40: 11996 case 0x50: 11997 case 0x60: 11998 case 0x70: 11999 case 0x80: 12000 case 0x90: 12001 case 0xa0: 12002 case 0xb0: 12003 case 0xc0: 12004 case 0xd0: 12005 case 0xe0: 12006 goto op_semantics_93; 12007 break; 12008 case 0xf0: 12009 goto op_semantics_94; 12010 break; 12011 } 12012 break; 12013 case 0xe8: 12014 GETBYTE (); 12015 switch (op[2] & 0xf0) 12016 { 12017 case 0x00: 12018 case 0x10: 12019 case 0x20: 12020 case 0x30: 12021 case 0x40: 12022 case 0x50: 12023 case 0x60: 12024 case 0x70: 12025 case 0x80: 12026 case 0x90: 12027 case 0xa0: 12028 case 0xb0: 12029 case 0xc0: 12030 case 0xd0: 12031 case 0xe0: 12032 goto op_semantics_93; 12033 break; 12034 case 0xf0: 12035 goto op_semantics_94; 12036 break; 12037 } 12038 break; 12039 case 0xe9: 12040 GETBYTE (); 12041 switch (op[2] & 0xf0) 12042 { 12043 case 0x00: 12044 case 0x10: 12045 case 0x20: 12046 case 0x30: 12047 case 0x40: 12048 case 0x50: 12049 case 0x60: 12050 case 0x70: 12051 case 0x80: 12052 case 0x90: 12053 case 0xa0: 12054 case 0xb0: 12055 case 0xc0: 12056 case 0xd0: 12057 case 0xe0: 12058 goto op_semantics_93; 12059 break; 12060 case 0xf0: 12061 goto op_semantics_94; 12062 break; 12063 } 12064 break; 12065 case 0xea: 12066 GETBYTE (); 12067 switch (op[2] & 0xf0) 12068 { 12069 case 0x00: 12070 case 0x10: 12071 case 0x20: 12072 case 0x30: 12073 case 0x40: 12074 case 0x50: 12075 case 0x60: 12076 case 0x70: 12077 case 0x80: 12078 case 0x90: 12079 case 0xa0: 12080 case 0xb0: 12081 case 0xc0: 12082 case 0xd0: 12083 case 0xe0: 12084 goto op_semantics_93; 12085 break; 12086 case 0xf0: 12087 goto op_semantics_94; 12088 break; 12089 } 12090 break; 12091 case 0xeb: 12092 GETBYTE (); 12093 switch (op[2] & 0xf0) 12094 { 12095 case 0x00: 12096 case 0x10: 12097 case 0x20: 12098 case 0x30: 12099 case 0x40: 12100 case 0x50: 12101 case 0x60: 12102 case 0x70: 12103 case 0x80: 12104 case 0x90: 12105 case 0xa0: 12106 case 0xb0: 12107 case 0xc0: 12108 case 0xd0: 12109 case 0xe0: 12110 goto op_semantics_93; 12111 break; 12112 case 0xf0: 12113 goto op_semantics_94; 12114 break; 12115 } 12116 break; 12117 case 0xec: 12118 GETBYTE (); 12119 switch (op[2] & 0xf0) 12120 { 12121 case 0x00: 12122 case 0x10: 12123 case 0x20: 12124 case 0x30: 12125 case 0x40: 12126 case 0x50: 12127 case 0x60: 12128 case 0x70: 12129 case 0x80: 12130 case 0x90: 12131 case 0xa0: 12132 case 0xb0: 12133 case 0xc0: 12134 case 0xd0: 12135 case 0xe0: 12136 goto op_semantics_93; 12137 break; 12138 case 0xf0: 12139 goto op_semantics_94; 12140 break; 12141 } 12142 break; 12143 case 0xed: 12144 GETBYTE (); 12145 switch (op[2] & 0xf0) 12146 { 12147 case 0x00: 12148 case 0x10: 12149 case 0x20: 12150 case 0x30: 12151 case 0x40: 12152 case 0x50: 12153 case 0x60: 12154 case 0x70: 12155 case 0x80: 12156 case 0x90: 12157 case 0xa0: 12158 case 0xb0: 12159 case 0xc0: 12160 case 0xd0: 12161 case 0xe0: 12162 goto op_semantics_93; 12163 break; 12164 case 0xf0: 12165 goto op_semantics_94; 12166 break; 12167 } 12168 break; 12169 case 0xee: 12170 GETBYTE (); 12171 switch (op[2] & 0xf0) 12172 { 12173 case 0x00: 12174 case 0x10: 12175 case 0x20: 12176 case 0x30: 12177 case 0x40: 12178 case 0x50: 12179 case 0x60: 12180 case 0x70: 12181 case 0x80: 12182 case 0x90: 12183 case 0xa0: 12184 case 0xb0: 12185 case 0xc0: 12186 case 0xd0: 12187 case 0xe0: 12188 goto op_semantics_93; 12189 break; 12190 case 0xf0: 12191 goto op_semantics_94; 12192 break; 12193 } 12194 break; 12195 case 0xef: 12196 GETBYTE (); 12197 switch (op[2] & 0xf0) 12198 { 12199 case 0x00: 12200 case 0x10: 12201 case 0x20: 12202 case 0x30: 12203 case 0x40: 12204 case 0x50: 12205 case 0x60: 12206 case 0x70: 12207 case 0x80: 12208 case 0x90: 12209 case 0xa0: 12210 case 0xb0: 12211 case 0xc0: 12212 case 0xd0: 12213 case 0xe0: 12214 goto op_semantics_93; 12215 break; 12216 case 0xf0: 12217 goto op_semantics_94; 12218 break; 12219 } 12220 break; 12221 case 0xf0: 12222 GETBYTE (); 12223 switch (op[2] & 0xf0) 12224 { 12225 case 0x00: 12226 case 0x10: 12227 case 0x20: 12228 case 0x30: 12229 case 0x40: 12230 case 0x50: 12231 case 0x60: 12232 case 0x70: 12233 case 0x80: 12234 case 0x90: 12235 case 0xa0: 12236 case 0xb0: 12237 case 0xc0: 12238 case 0xd0: 12239 case 0xe0: 12240 goto op_semantics_93; 12241 break; 12242 case 0xf0: 12243 goto op_semantics_94; 12244 break; 12245 } 12246 break; 12247 case 0xf1: 12248 GETBYTE (); 12249 switch (op[2] & 0xf0) 12250 { 12251 case 0x00: 12252 case 0x10: 12253 case 0x20: 12254 case 0x30: 12255 case 0x40: 12256 case 0x50: 12257 case 0x60: 12258 case 0x70: 12259 case 0x80: 12260 case 0x90: 12261 case 0xa0: 12262 case 0xb0: 12263 case 0xc0: 12264 case 0xd0: 12265 case 0xe0: 12266 goto op_semantics_93; 12267 break; 12268 case 0xf0: 12269 goto op_semantics_94; 12270 break; 12271 } 12272 break; 12273 case 0xf2: 12274 GETBYTE (); 12275 switch (op[2] & 0xf0) 12276 { 12277 case 0x00: 12278 case 0x10: 12279 case 0x20: 12280 case 0x30: 12281 case 0x40: 12282 case 0x50: 12283 case 0x60: 12284 case 0x70: 12285 case 0x80: 12286 case 0x90: 12287 case 0xa0: 12288 case 0xb0: 12289 case 0xc0: 12290 case 0xd0: 12291 case 0xe0: 12292 goto op_semantics_93; 12293 break; 12294 case 0xf0: 12295 goto op_semantics_94; 12296 break; 12297 } 12298 break; 12299 case 0xf3: 12300 GETBYTE (); 12301 switch (op[2] & 0xf0) 12302 { 12303 case 0x00: 12304 case 0x10: 12305 case 0x20: 12306 case 0x30: 12307 case 0x40: 12308 case 0x50: 12309 case 0x60: 12310 case 0x70: 12311 case 0x80: 12312 case 0x90: 12313 case 0xa0: 12314 case 0xb0: 12315 case 0xc0: 12316 case 0xd0: 12317 case 0xe0: 12318 goto op_semantics_93; 12319 break; 12320 case 0xf0: 12321 goto op_semantics_94; 12322 break; 12323 } 12324 break; 12325 case 0xf4: 12326 GETBYTE (); 12327 switch (op[2] & 0xf0) 12328 { 12329 case 0x00: 12330 case 0x10: 12331 case 0x20: 12332 case 0x30: 12333 case 0x40: 12334 case 0x50: 12335 case 0x60: 12336 case 0x70: 12337 case 0x80: 12338 case 0x90: 12339 case 0xa0: 12340 case 0xb0: 12341 case 0xc0: 12342 case 0xd0: 12343 case 0xe0: 12344 goto op_semantics_93; 12345 break; 12346 case 0xf0: 12347 goto op_semantics_94; 12348 break; 12349 } 12350 break; 12351 case 0xf5: 12352 GETBYTE (); 12353 switch (op[2] & 0xf0) 12354 { 12355 case 0x00: 12356 case 0x10: 12357 case 0x20: 12358 case 0x30: 12359 case 0x40: 12360 case 0x50: 12361 case 0x60: 12362 case 0x70: 12363 case 0x80: 12364 case 0x90: 12365 case 0xa0: 12366 case 0xb0: 12367 case 0xc0: 12368 case 0xd0: 12369 case 0xe0: 12370 goto op_semantics_93; 12371 break; 12372 case 0xf0: 12373 goto op_semantics_94; 12374 break; 12375 } 12376 break; 12377 case 0xf6: 12378 GETBYTE (); 12379 switch (op[2] & 0xf0) 12380 { 12381 case 0x00: 12382 case 0x10: 12383 case 0x20: 12384 case 0x30: 12385 case 0x40: 12386 case 0x50: 12387 case 0x60: 12388 case 0x70: 12389 case 0x80: 12390 case 0x90: 12391 case 0xa0: 12392 case 0xb0: 12393 case 0xc0: 12394 case 0xd0: 12395 case 0xe0: 12396 goto op_semantics_93; 12397 break; 12398 case 0xf0: 12399 goto op_semantics_94; 12400 break; 12401 } 12402 break; 12403 case 0xf7: 12404 GETBYTE (); 12405 switch (op[2] & 0xf0) 12406 { 12407 case 0x00: 12408 case 0x10: 12409 case 0x20: 12410 case 0x30: 12411 case 0x40: 12412 case 0x50: 12413 case 0x60: 12414 case 0x70: 12415 case 0x80: 12416 case 0x90: 12417 case 0xa0: 12418 case 0xb0: 12419 case 0xc0: 12420 case 0xd0: 12421 case 0xe0: 12422 goto op_semantics_93; 12423 break; 12424 case 0xf0: 12425 goto op_semantics_94; 12426 break; 12427 } 12428 break; 12429 case 0xf8: 12430 GETBYTE (); 12431 switch (op[2] & 0xf0) 12432 { 12433 case 0x00: 12434 case 0x10: 12435 case 0x20: 12436 case 0x30: 12437 case 0x40: 12438 case 0x50: 12439 case 0x60: 12440 case 0x70: 12441 case 0x80: 12442 case 0x90: 12443 case 0xa0: 12444 case 0xb0: 12445 case 0xc0: 12446 case 0xd0: 12447 case 0xe0: 12448 goto op_semantics_93; 12449 break; 12450 case 0xf0: 12451 goto op_semantics_94; 12452 break; 12453 } 12454 break; 12455 case 0xf9: 12456 GETBYTE (); 12457 switch (op[2] & 0xf0) 12458 { 12459 case 0x00: 12460 case 0x10: 12461 case 0x20: 12462 case 0x30: 12463 case 0x40: 12464 case 0x50: 12465 case 0x60: 12466 case 0x70: 12467 case 0x80: 12468 case 0x90: 12469 case 0xa0: 12470 case 0xb0: 12471 case 0xc0: 12472 case 0xd0: 12473 case 0xe0: 12474 goto op_semantics_93; 12475 break; 12476 case 0xf0: 12477 goto op_semantics_94; 12478 break; 12479 } 12480 break; 12481 case 0xfa: 12482 GETBYTE (); 12483 switch (op[2] & 0xf0) 12484 { 12485 case 0x00: 12486 case 0x10: 12487 case 0x20: 12488 case 0x30: 12489 case 0x40: 12490 case 0x50: 12491 case 0x60: 12492 case 0x70: 12493 case 0x80: 12494 case 0x90: 12495 case 0xa0: 12496 case 0xb0: 12497 case 0xc0: 12498 case 0xd0: 12499 case 0xe0: 12500 goto op_semantics_93; 12501 break; 12502 case 0xf0: 12503 goto op_semantics_94; 12504 break; 12505 } 12506 break; 12507 case 0xfb: 12508 GETBYTE (); 12509 switch (op[2] & 0xf0) 12510 { 12511 case 0x00: 12512 case 0x10: 12513 case 0x20: 12514 case 0x30: 12515 case 0x40: 12516 case 0x50: 12517 case 0x60: 12518 case 0x70: 12519 case 0x80: 12520 case 0x90: 12521 case 0xa0: 12522 case 0xb0: 12523 case 0xc0: 12524 case 0xd0: 12525 case 0xe0: 12526 goto op_semantics_93; 12527 break; 12528 case 0xf0: 12529 goto op_semantics_94; 12530 break; 12531 } 12532 break; 12533 case 0xfc: 12534 GETBYTE (); 12535 switch (op[2] & 0xf0) 12536 { 12537 case 0x00: 12538 case 0x10: 12539 case 0x20: 12540 case 0x30: 12541 case 0x40: 12542 case 0x50: 12543 case 0x60: 12544 case 0x70: 12545 case 0x80: 12546 case 0x90: 12547 case 0xa0: 12548 case 0xb0: 12549 case 0xc0: 12550 case 0xd0: 12551 case 0xe0: 12552 goto op_semantics_93; 12553 break; 12554 case 0xf0: 12555 goto op_semantics_94; 12556 break; 12557 } 12558 break; 12559 case 0xfd: 12560 GETBYTE (); 12561 switch (op[2] & 0xf0) 12562 { 12563 case 0x00: 12564 case 0x10: 12565 case 0x20: 12566 case 0x30: 12567 case 0x40: 12568 case 0x50: 12569 case 0x60: 12570 case 0x70: 12571 case 0x80: 12572 case 0x90: 12573 case 0xa0: 12574 case 0xb0: 12575 case 0xc0: 12576 case 0xd0: 12577 case 0xe0: 12578 goto op_semantics_93; 12579 break; 12580 case 0xf0: 12581 goto op_semantics_94; 12582 break; 12583 } 12584 break; 12585 case 0xfe: 12586 GETBYTE (); 12587 switch (op[2] & 0xf0) 12588 { 12589 case 0x00: 12590 case 0x10: 12591 case 0x20: 12592 case 0x30: 12593 case 0x40: 12594 case 0x50: 12595 case 0x60: 12596 case 0x70: 12597 case 0x80: 12598 case 0x90: 12599 case 0xa0: 12600 case 0xb0: 12601 case 0xc0: 12602 case 0xd0: 12603 case 0xe0: 12604 goto op_semantics_93; 12605 break; 12606 case 0xf0: 12607 goto op_semantics_94; 12608 break; 12609 } 12610 break; 12611 case 0xff: 12612 GETBYTE (); 12613 switch (op[2] & 0xf0) 12614 { 12615 case 0x00: 12616 case 0x10: 12617 case 0x20: 12618 case 0x30: 12619 case 0x40: 12620 case 0x50: 12621 case 0x60: 12622 case 0x70: 12623 case 0x80: 12624 case 0x90: 12625 case 0xa0: 12626 case 0xb0: 12627 case 0xc0: 12628 case 0xd0: 12629 case 0xe0: 12630 goto op_semantics_93; 12631 break; 12632 case 0xf0: 12633 goto op_semantics_94; 12634 break; 12635 } 12636 break; 12637 default: UNSUPPORTED(); break; 12638 } 12639 break; 12640 case 0xfe: 12641 GETBYTE (); 12642 switch (op[1] & 0xff) 12643 { 12644 case 0x00: 12645 GETBYTE (); 12646 switch (op[2] & 0x00) 12647 { 12648 case 0x00: 12649 op_semantics_95: 12650 { 12651 /** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */ 12652 #line 335 "rx-decode.opc" 12653 int sz AU = (op[1] >> 4) & 0x03; 12654 #line 335 "rx-decode.opc" 12655 int isrc AU = op[1] & 0x0f; 12656 #line 335 "rx-decode.opc" 12657 int bsrc AU = (op[2] >> 4) & 0x0f; 12658 #line 335 "rx-decode.opc" 12659 int rdst AU = op[2] & 0x0f; 12660 if (trace) 12661 { 12662 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12663 "/** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */", 12664 op[0], op[1], op[2]); 12665 printf (" sz = 0x%x,", sz); 12666 printf (" isrc = 0x%x,", isrc); 12667 printf (" bsrc = 0x%x,", bsrc); 12668 printf (" rdst = 0x%x\n", rdst); 12669 } 12670 SYNTAX("mov%s %0, [%1, %2]"); 12671 #line 335 "rx-decode.opc" 12672 ID(movbir); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____; 12673 12674 } 12675 break; 12676 } 12677 break; 12678 case 0x01: 12679 GETBYTE (); 12680 switch (op[2] & 0x00) 12681 { 12682 case 0x00: 12683 goto op_semantics_95; 12684 break; 12685 } 12686 break; 12687 case 0x02: 12688 GETBYTE (); 12689 switch (op[2] & 0x00) 12690 { 12691 case 0x00: 12692 goto op_semantics_95; 12693 break; 12694 } 12695 break; 12696 case 0x03: 12697 GETBYTE (); 12698 switch (op[2] & 0x00) 12699 { 12700 case 0x00: 12701 goto op_semantics_95; 12702 break; 12703 } 12704 break; 12705 case 0x04: 12706 GETBYTE (); 12707 switch (op[2] & 0x00) 12708 { 12709 case 0x00: 12710 goto op_semantics_95; 12711 break; 12712 } 12713 break; 12714 case 0x05: 12715 GETBYTE (); 12716 switch (op[2] & 0x00) 12717 { 12718 case 0x00: 12719 goto op_semantics_95; 12720 break; 12721 } 12722 break; 12723 case 0x06: 12724 GETBYTE (); 12725 switch (op[2] & 0x00) 12726 { 12727 case 0x00: 12728 goto op_semantics_95; 12729 break; 12730 } 12731 break; 12732 case 0x07: 12733 GETBYTE (); 12734 switch (op[2] & 0x00) 12735 { 12736 case 0x00: 12737 goto op_semantics_95; 12738 break; 12739 } 12740 break; 12741 case 0x08: 12742 GETBYTE (); 12743 switch (op[2] & 0x00) 12744 { 12745 case 0x00: 12746 goto op_semantics_95; 12747 break; 12748 } 12749 break; 12750 case 0x09: 12751 GETBYTE (); 12752 switch (op[2] & 0x00) 12753 { 12754 case 0x00: 12755 goto op_semantics_95; 12756 break; 12757 } 12758 break; 12759 case 0x0a: 12760 GETBYTE (); 12761 switch (op[2] & 0x00) 12762 { 12763 case 0x00: 12764 goto op_semantics_95; 12765 break; 12766 } 12767 break; 12768 case 0x0b: 12769 GETBYTE (); 12770 switch (op[2] & 0x00) 12771 { 12772 case 0x00: 12773 goto op_semantics_95; 12774 break; 12775 } 12776 break; 12777 case 0x0c: 12778 GETBYTE (); 12779 switch (op[2] & 0x00) 12780 { 12781 case 0x00: 12782 goto op_semantics_95; 12783 break; 12784 } 12785 break; 12786 case 0x0d: 12787 GETBYTE (); 12788 switch (op[2] & 0x00) 12789 { 12790 case 0x00: 12791 goto op_semantics_95; 12792 break; 12793 } 12794 break; 12795 case 0x0e: 12796 GETBYTE (); 12797 switch (op[2] & 0x00) 12798 { 12799 case 0x00: 12800 goto op_semantics_95; 12801 break; 12802 } 12803 break; 12804 case 0x0f: 12805 GETBYTE (); 12806 switch (op[2] & 0x00) 12807 { 12808 case 0x00: 12809 goto op_semantics_95; 12810 break; 12811 } 12812 break; 12813 case 0x10: 12814 GETBYTE (); 12815 switch (op[2] & 0x00) 12816 { 12817 case 0x00: 12818 goto op_semantics_95; 12819 break; 12820 } 12821 break; 12822 case 0x11: 12823 GETBYTE (); 12824 switch (op[2] & 0x00) 12825 { 12826 case 0x00: 12827 goto op_semantics_95; 12828 break; 12829 } 12830 break; 12831 case 0x12: 12832 GETBYTE (); 12833 switch (op[2] & 0x00) 12834 { 12835 case 0x00: 12836 goto op_semantics_95; 12837 break; 12838 } 12839 break; 12840 case 0x13: 12841 GETBYTE (); 12842 switch (op[2] & 0x00) 12843 { 12844 case 0x00: 12845 goto op_semantics_95; 12846 break; 12847 } 12848 break; 12849 case 0x14: 12850 GETBYTE (); 12851 switch (op[2] & 0x00) 12852 { 12853 case 0x00: 12854 goto op_semantics_95; 12855 break; 12856 } 12857 break; 12858 case 0x15: 12859 GETBYTE (); 12860 switch (op[2] & 0x00) 12861 { 12862 case 0x00: 12863 goto op_semantics_95; 12864 break; 12865 } 12866 break; 12867 case 0x16: 12868 GETBYTE (); 12869 switch (op[2] & 0x00) 12870 { 12871 case 0x00: 12872 goto op_semantics_95; 12873 break; 12874 } 12875 break; 12876 case 0x17: 12877 GETBYTE (); 12878 switch (op[2] & 0x00) 12879 { 12880 case 0x00: 12881 goto op_semantics_95; 12882 break; 12883 } 12884 break; 12885 case 0x18: 12886 GETBYTE (); 12887 switch (op[2] & 0x00) 12888 { 12889 case 0x00: 12890 goto op_semantics_95; 12891 break; 12892 } 12893 break; 12894 case 0x19: 12895 GETBYTE (); 12896 switch (op[2] & 0x00) 12897 { 12898 case 0x00: 12899 goto op_semantics_95; 12900 break; 12901 } 12902 break; 12903 case 0x1a: 12904 GETBYTE (); 12905 switch (op[2] & 0x00) 12906 { 12907 case 0x00: 12908 goto op_semantics_95; 12909 break; 12910 } 12911 break; 12912 case 0x1b: 12913 GETBYTE (); 12914 switch (op[2] & 0x00) 12915 { 12916 case 0x00: 12917 goto op_semantics_95; 12918 break; 12919 } 12920 break; 12921 case 0x1c: 12922 GETBYTE (); 12923 switch (op[2] & 0x00) 12924 { 12925 case 0x00: 12926 goto op_semantics_95; 12927 break; 12928 } 12929 break; 12930 case 0x1d: 12931 GETBYTE (); 12932 switch (op[2] & 0x00) 12933 { 12934 case 0x00: 12935 goto op_semantics_95; 12936 break; 12937 } 12938 break; 12939 case 0x1e: 12940 GETBYTE (); 12941 switch (op[2] & 0x00) 12942 { 12943 case 0x00: 12944 goto op_semantics_95; 12945 break; 12946 } 12947 break; 12948 case 0x1f: 12949 GETBYTE (); 12950 switch (op[2] & 0x00) 12951 { 12952 case 0x00: 12953 goto op_semantics_95; 12954 break; 12955 } 12956 break; 12957 case 0x20: 12958 GETBYTE (); 12959 switch (op[2] & 0x00) 12960 { 12961 case 0x00: 12962 goto op_semantics_95; 12963 break; 12964 } 12965 break; 12966 case 0x21: 12967 GETBYTE (); 12968 switch (op[2] & 0x00) 12969 { 12970 case 0x00: 12971 goto op_semantics_95; 12972 break; 12973 } 12974 break; 12975 case 0x22: 12976 GETBYTE (); 12977 switch (op[2] & 0x00) 12978 { 12979 case 0x00: 12980 goto op_semantics_95; 12981 break; 12982 } 12983 break; 12984 case 0x23: 12985 GETBYTE (); 12986 switch (op[2] & 0x00) 12987 { 12988 case 0x00: 12989 goto op_semantics_95; 12990 break; 12991 } 12992 break; 12993 case 0x24: 12994 GETBYTE (); 12995 switch (op[2] & 0x00) 12996 { 12997 case 0x00: 12998 goto op_semantics_95; 12999 break; 13000 } 13001 break; 13002 case 0x25: 13003 GETBYTE (); 13004 switch (op[2] & 0x00) 13005 { 13006 case 0x00: 13007 goto op_semantics_95; 13008 break; 13009 } 13010 break; 13011 case 0x26: 13012 GETBYTE (); 13013 switch (op[2] & 0x00) 13014 { 13015 case 0x00: 13016 goto op_semantics_95; 13017 break; 13018 } 13019 break; 13020 case 0x27: 13021 GETBYTE (); 13022 switch (op[2] & 0x00) 13023 { 13024 case 0x00: 13025 goto op_semantics_95; 13026 break; 13027 } 13028 break; 13029 case 0x28: 13030 GETBYTE (); 13031 switch (op[2] & 0x00) 13032 { 13033 case 0x00: 13034 goto op_semantics_95; 13035 break; 13036 } 13037 break; 13038 case 0x29: 13039 GETBYTE (); 13040 switch (op[2] & 0x00) 13041 { 13042 case 0x00: 13043 goto op_semantics_95; 13044 break; 13045 } 13046 break; 13047 case 0x2a: 13048 GETBYTE (); 13049 switch (op[2] & 0x00) 13050 { 13051 case 0x00: 13052 goto op_semantics_95; 13053 break; 13054 } 13055 break; 13056 case 0x2b: 13057 GETBYTE (); 13058 switch (op[2] & 0x00) 13059 { 13060 case 0x00: 13061 goto op_semantics_95; 13062 break; 13063 } 13064 break; 13065 case 0x2c: 13066 GETBYTE (); 13067 switch (op[2] & 0x00) 13068 { 13069 case 0x00: 13070 goto op_semantics_95; 13071 break; 13072 } 13073 break; 13074 case 0x2d: 13075 GETBYTE (); 13076 switch (op[2] & 0x00) 13077 { 13078 case 0x00: 13079 goto op_semantics_95; 13080 break; 13081 } 13082 break; 13083 case 0x2e: 13084 GETBYTE (); 13085 switch (op[2] & 0x00) 13086 { 13087 case 0x00: 13088 goto op_semantics_95; 13089 break; 13090 } 13091 break; 13092 case 0x2f: 13093 GETBYTE (); 13094 switch (op[2] & 0x00) 13095 { 13096 case 0x00: 13097 goto op_semantics_95; 13098 break; 13099 } 13100 break; 13101 case 0x40: 13102 GETBYTE (); 13103 switch (op[2] & 0x00) 13104 { 13105 case 0x00: 13106 op_semantics_96: 13107 { 13108 /** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */ 13109 #line 332 "rx-decode.opc" 13110 int sz AU = (op[1] >> 4) & 0x03; 13111 #line 332 "rx-decode.opc" 13112 int isrc AU = op[1] & 0x0f; 13113 #line 332 "rx-decode.opc" 13114 int bsrc AU = (op[2] >> 4) & 0x0f; 13115 #line 332 "rx-decode.opc" 13116 int rdst AU = op[2] & 0x0f; 13117 if (trace) 13118 { 13119 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13120 "/** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */", 13121 op[0], op[1], op[2]); 13122 printf (" sz = 0x%x,", sz); 13123 printf (" isrc = 0x%x,", isrc); 13124 printf (" bsrc = 0x%x,", bsrc); 13125 printf (" rdst = 0x%x\n", rdst); 13126 } 13127 SYNTAX("mov%s [%1, %2], %0"); 13128 #line 332 "rx-decode.opc" 13129 ID(movbi); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____; 13130 13131 } 13132 break; 13133 } 13134 break; 13135 case 0x41: 13136 GETBYTE (); 13137 switch (op[2] & 0x00) 13138 { 13139 case 0x00: 13140 goto op_semantics_96; 13141 break; 13142 } 13143 break; 13144 case 0x42: 13145 GETBYTE (); 13146 switch (op[2] & 0x00) 13147 { 13148 case 0x00: 13149 goto op_semantics_96; 13150 break; 13151 } 13152 break; 13153 case 0x43: 13154 GETBYTE (); 13155 switch (op[2] & 0x00) 13156 { 13157 case 0x00: 13158 goto op_semantics_96; 13159 break; 13160 } 13161 break; 13162 case 0x44: 13163 GETBYTE (); 13164 switch (op[2] & 0x00) 13165 { 13166 case 0x00: 13167 goto op_semantics_96; 13168 break; 13169 } 13170 break; 13171 case 0x45: 13172 GETBYTE (); 13173 switch (op[2] & 0x00) 13174 { 13175 case 0x00: 13176 goto op_semantics_96; 13177 break; 13178 } 13179 break; 13180 case 0x46: 13181 GETBYTE (); 13182 switch (op[2] & 0x00) 13183 { 13184 case 0x00: 13185 goto op_semantics_96; 13186 break; 13187 } 13188 break; 13189 case 0x47: 13190 GETBYTE (); 13191 switch (op[2] & 0x00) 13192 { 13193 case 0x00: 13194 goto op_semantics_96; 13195 break; 13196 } 13197 break; 13198 case 0x48: 13199 GETBYTE (); 13200 switch (op[2] & 0x00) 13201 { 13202 case 0x00: 13203 goto op_semantics_96; 13204 break; 13205 } 13206 break; 13207 case 0x49: 13208 GETBYTE (); 13209 switch (op[2] & 0x00) 13210 { 13211 case 0x00: 13212 goto op_semantics_96; 13213 break; 13214 } 13215 break; 13216 case 0x4a: 13217 GETBYTE (); 13218 switch (op[2] & 0x00) 13219 { 13220 case 0x00: 13221 goto op_semantics_96; 13222 break; 13223 } 13224 break; 13225 case 0x4b: 13226 GETBYTE (); 13227 switch (op[2] & 0x00) 13228 { 13229 case 0x00: 13230 goto op_semantics_96; 13231 break; 13232 } 13233 break; 13234 case 0x4c: 13235 GETBYTE (); 13236 switch (op[2] & 0x00) 13237 { 13238 case 0x00: 13239 goto op_semantics_96; 13240 break; 13241 } 13242 break; 13243 case 0x4d: 13244 GETBYTE (); 13245 switch (op[2] & 0x00) 13246 { 13247 case 0x00: 13248 goto op_semantics_96; 13249 break; 13250 } 13251 break; 13252 case 0x4e: 13253 GETBYTE (); 13254 switch (op[2] & 0x00) 13255 { 13256 case 0x00: 13257 goto op_semantics_96; 13258 break; 13259 } 13260 break; 13261 case 0x4f: 13262 GETBYTE (); 13263 switch (op[2] & 0x00) 13264 { 13265 case 0x00: 13266 goto op_semantics_96; 13267 break; 13268 } 13269 break; 13270 case 0x50: 13271 GETBYTE (); 13272 switch (op[2] & 0x00) 13273 { 13274 case 0x00: 13275 goto op_semantics_96; 13276 break; 13277 } 13278 break; 13279 case 0x51: 13280 GETBYTE (); 13281 switch (op[2] & 0x00) 13282 { 13283 case 0x00: 13284 goto op_semantics_96; 13285 break; 13286 } 13287 break; 13288 case 0x52: 13289 GETBYTE (); 13290 switch (op[2] & 0x00) 13291 { 13292 case 0x00: 13293 goto op_semantics_96; 13294 break; 13295 } 13296 break; 13297 case 0x53: 13298 GETBYTE (); 13299 switch (op[2] & 0x00) 13300 { 13301 case 0x00: 13302 goto op_semantics_96; 13303 break; 13304 } 13305 break; 13306 case 0x54: 13307 GETBYTE (); 13308 switch (op[2] & 0x00) 13309 { 13310 case 0x00: 13311 goto op_semantics_96; 13312 break; 13313 } 13314 break; 13315 case 0x55: 13316 GETBYTE (); 13317 switch (op[2] & 0x00) 13318 { 13319 case 0x00: 13320 goto op_semantics_96; 13321 break; 13322 } 13323 break; 13324 case 0x56: 13325 GETBYTE (); 13326 switch (op[2] & 0x00) 13327 { 13328 case 0x00: 13329 goto op_semantics_96; 13330 break; 13331 } 13332 break; 13333 case 0x57: 13334 GETBYTE (); 13335 switch (op[2] & 0x00) 13336 { 13337 case 0x00: 13338 goto op_semantics_96; 13339 break; 13340 } 13341 break; 13342 case 0x58: 13343 GETBYTE (); 13344 switch (op[2] & 0x00) 13345 { 13346 case 0x00: 13347 goto op_semantics_96; 13348 break; 13349 } 13350 break; 13351 case 0x59: 13352 GETBYTE (); 13353 switch (op[2] & 0x00) 13354 { 13355 case 0x00: 13356 goto op_semantics_96; 13357 break; 13358 } 13359 break; 13360 case 0x5a: 13361 GETBYTE (); 13362 switch (op[2] & 0x00) 13363 { 13364 case 0x00: 13365 goto op_semantics_96; 13366 break; 13367 } 13368 break; 13369 case 0x5b: 13370 GETBYTE (); 13371 switch (op[2] & 0x00) 13372 { 13373 case 0x00: 13374 goto op_semantics_96; 13375 break; 13376 } 13377 break; 13378 case 0x5c: 13379 GETBYTE (); 13380 switch (op[2] & 0x00) 13381 { 13382 case 0x00: 13383 goto op_semantics_96; 13384 break; 13385 } 13386 break; 13387 case 0x5d: 13388 GETBYTE (); 13389 switch (op[2] & 0x00) 13390 { 13391 case 0x00: 13392 goto op_semantics_96; 13393 break; 13394 } 13395 break; 13396 case 0x5e: 13397 GETBYTE (); 13398 switch (op[2] & 0x00) 13399 { 13400 case 0x00: 13401 goto op_semantics_96; 13402 break; 13403 } 13404 break; 13405 case 0x5f: 13406 GETBYTE (); 13407 switch (op[2] & 0x00) 13408 { 13409 case 0x00: 13410 goto op_semantics_96; 13411 break; 13412 } 13413 break; 13414 case 0x60: 13415 GETBYTE (); 13416 switch (op[2] & 0x00) 13417 { 13418 case 0x00: 13419 goto op_semantics_96; 13420 break; 13421 } 13422 break; 13423 case 0x61: 13424 GETBYTE (); 13425 switch (op[2] & 0x00) 13426 { 13427 case 0x00: 13428 goto op_semantics_96; 13429 break; 13430 } 13431 break; 13432 case 0x62: 13433 GETBYTE (); 13434 switch (op[2] & 0x00) 13435 { 13436 case 0x00: 13437 goto op_semantics_96; 13438 break; 13439 } 13440 break; 13441 case 0x63: 13442 GETBYTE (); 13443 switch (op[2] & 0x00) 13444 { 13445 case 0x00: 13446 goto op_semantics_96; 13447 break; 13448 } 13449 break; 13450 case 0x64: 13451 GETBYTE (); 13452 switch (op[2] & 0x00) 13453 { 13454 case 0x00: 13455 goto op_semantics_96; 13456 break; 13457 } 13458 break; 13459 case 0x65: 13460 GETBYTE (); 13461 switch (op[2] & 0x00) 13462 { 13463 case 0x00: 13464 goto op_semantics_96; 13465 break; 13466 } 13467 break; 13468 case 0x66: 13469 GETBYTE (); 13470 switch (op[2] & 0x00) 13471 { 13472 case 0x00: 13473 goto op_semantics_96; 13474 break; 13475 } 13476 break; 13477 case 0x67: 13478 GETBYTE (); 13479 switch (op[2] & 0x00) 13480 { 13481 case 0x00: 13482 goto op_semantics_96; 13483 break; 13484 } 13485 break; 13486 case 0x68: 13487 GETBYTE (); 13488 switch (op[2] & 0x00) 13489 { 13490 case 0x00: 13491 goto op_semantics_96; 13492 break; 13493 } 13494 break; 13495 case 0x69: 13496 GETBYTE (); 13497 switch (op[2] & 0x00) 13498 { 13499 case 0x00: 13500 goto op_semantics_96; 13501 break; 13502 } 13503 break; 13504 case 0x6a: 13505 GETBYTE (); 13506 switch (op[2] & 0x00) 13507 { 13508 case 0x00: 13509 goto op_semantics_96; 13510 break; 13511 } 13512 break; 13513 case 0x6b: 13514 GETBYTE (); 13515 switch (op[2] & 0x00) 13516 { 13517 case 0x00: 13518 goto op_semantics_96; 13519 break; 13520 } 13521 break; 13522 case 0x6c: 13523 GETBYTE (); 13524 switch (op[2] & 0x00) 13525 { 13526 case 0x00: 13527 goto op_semantics_96; 13528 break; 13529 } 13530 break; 13531 case 0x6d: 13532 GETBYTE (); 13533 switch (op[2] & 0x00) 13534 { 13535 case 0x00: 13536 goto op_semantics_96; 13537 break; 13538 } 13539 break; 13540 case 0x6e: 13541 GETBYTE (); 13542 switch (op[2] & 0x00) 13543 { 13544 case 0x00: 13545 goto op_semantics_96; 13546 break; 13547 } 13548 break; 13549 case 0x6f: 13550 GETBYTE (); 13551 switch (op[2] & 0x00) 13552 { 13553 case 0x00: 13554 goto op_semantics_96; 13555 break; 13556 } 13557 break; 13558 case 0xc0: 13559 GETBYTE (); 13560 switch (op[2] & 0x00) 13561 { 13562 case 0x00: 13563 op_semantics_97: 13564 { 13565 /** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */ 13566 #line 338 "rx-decode.opc" 13567 int sz AU = (op[1] >> 4) & 0x03; 13568 #line 338 "rx-decode.opc" 13569 int isrc AU = op[1] & 0x0f; 13570 #line 338 "rx-decode.opc" 13571 int bsrc AU = (op[2] >> 4) & 0x0f; 13572 #line 338 "rx-decode.opc" 13573 int rdst AU = op[2] & 0x0f; 13574 if (trace) 13575 { 13576 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13577 "/** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */", 13578 op[0], op[1], op[2]); 13579 printf (" sz = 0x%x,", sz); 13580 printf (" isrc = 0x%x,", isrc); 13581 printf (" bsrc = 0x%x,", bsrc); 13582 printf (" rdst = 0x%x\n", rdst); 13583 } 13584 SYNTAX("movu%s [%1, %2], %0"); 13585 #line 338 "rx-decode.opc" 13586 ID(movbi); uBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____; 13587 13588 } 13589 break; 13590 } 13591 break; 13592 case 0xc1: 13593 GETBYTE (); 13594 switch (op[2] & 0x00) 13595 { 13596 case 0x00: 13597 goto op_semantics_97; 13598 break; 13599 } 13600 break; 13601 case 0xc2: 13602 GETBYTE (); 13603 switch (op[2] & 0x00) 13604 { 13605 case 0x00: 13606 goto op_semantics_97; 13607 break; 13608 } 13609 break; 13610 case 0xc3: 13611 GETBYTE (); 13612 switch (op[2] & 0x00) 13613 { 13614 case 0x00: 13615 goto op_semantics_97; 13616 break; 13617 } 13618 break; 13619 case 0xc4: 13620 GETBYTE (); 13621 switch (op[2] & 0x00) 13622 { 13623 case 0x00: 13624 goto op_semantics_97; 13625 break; 13626 } 13627 break; 13628 case 0xc5: 13629 GETBYTE (); 13630 switch (op[2] & 0x00) 13631 { 13632 case 0x00: 13633 goto op_semantics_97; 13634 break; 13635 } 13636 break; 13637 case 0xc6: 13638 GETBYTE (); 13639 switch (op[2] & 0x00) 13640 { 13641 case 0x00: 13642 goto op_semantics_97; 13643 break; 13644 } 13645 break; 13646 case 0xc7: 13647 GETBYTE (); 13648 switch (op[2] & 0x00) 13649 { 13650 case 0x00: 13651 goto op_semantics_97; 13652 break; 13653 } 13654 break; 13655 case 0xc8: 13656 GETBYTE (); 13657 switch (op[2] & 0x00) 13658 { 13659 case 0x00: 13660 goto op_semantics_97; 13661 break; 13662 } 13663 break; 13664 case 0xc9: 13665 GETBYTE (); 13666 switch (op[2] & 0x00) 13667 { 13668 case 0x00: 13669 goto op_semantics_97; 13670 break; 13671 } 13672 break; 13673 case 0xca: 13674 GETBYTE (); 13675 switch (op[2] & 0x00) 13676 { 13677 case 0x00: 13678 goto op_semantics_97; 13679 break; 13680 } 13681 break; 13682 case 0xcb: 13683 GETBYTE (); 13684 switch (op[2] & 0x00) 13685 { 13686 case 0x00: 13687 goto op_semantics_97; 13688 break; 13689 } 13690 break; 13691 case 0xcc: 13692 GETBYTE (); 13693 switch (op[2] & 0x00) 13694 { 13695 case 0x00: 13696 goto op_semantics_97; 13697 break; 13698 } 13699 break; 13700 case 0xcd: 13701 GETBYTE (); 13702 switch (op[2] & 0x00) 13703 { 13704 case 0x00: 13705 goto op_semantics_97; 13706 break; 13707 } 13708 break; 13709 case 0xce: 13710 GETBYTE (); 13711 switch (op[2] & 0x00) 13712 { 13713 case 0x00: 13714 goto op_semantics_97; 13715 break; 13716 } 13717 break; 13718 case 0xcf: 13719 GETBYTE (); 13720 switch (op[2] & 0x00) 13721 { 13722 case 0x00: 13723 goto op_semantics_97; 13724 break; 13725 } 13726 break; 13727 case 0xd0: 13728 GETBYTE (); 13729 switch (op[2] & 0x00) 13730 { 13731 case 0x00: 13732 goto op_semantics_97; 13733 break; 13734 } 13735 break; 13736 case 0xd1: 13737 GETBYTE (); 13738 switch (op[2] & 0x00) 13739 { 13740 case 0x00: 13741 goto op_semantics_97; 13742 break; 13743 } 13744 break; 13745 case 0xd2: 13746 GETBYTE (); 13747 switch (op[2] & 0x00) 13748 { 13749 case 0x00: 13750 goto op_semantics_97; 13751 break; 13752 } 13753 break; 13754 case 0xd3: 13755 GETBYTE (); 13756 switch (op[2] & 0x00) 13757 { 13758 case 0x00: 13759 goto op_semantics_97; 13760 break; 13761 } 13762 break; 13763 case 0xd4: 13764 GETBYTE (); 13765 switch (op[2] & 0x00) 13766 { 13767 case 0x00: 13768 goto op_semantics_97; 13769 break; 13770 } 13771 break; 13772 case 0xd5: 13773 GETBYTE (); 13774 switch (op[2] & 0x00) 13775 { 13776 case 0x00: 13777 goto op_semantics_97; 13778 break; 13779 } 13780 break; 13781 case 0xd6: 13782 GETBYTE (); 13783 switch (op[2] & 0x00) 13784 { 13785 case 0x00: 13786 goto op_semantics_97; 13787 break; 13788 } 13789 break; 13790 case 0xd7: 13791 GETBYTE (); 13792 switch (op[2] & 0x00) 13793 { 13794 case 0x00: 13795 goto op_semantics_97; 13796 break; 13797 } 13798 break; 13799 case 0xd8: 13800 GETBYTE (); 13801 switch (op[2] & 0x00) 13802 { 13803 case 0x00: 13804 goto op_semantics_97; 13805 break; 13806 } 13807 break; 13808 case 0xd9: 13809 GETBYTE (); 13810 switch (op[2] & 0x00) 13811 { 13812 case 0x00: 13813 goto op_semantics_97; 13814 break; 13815 } 13816 break; 13817 case 0xda: 13818 GETBYTE (); 13819 switch (op[2] & 0x00) 13820 { 13821 case 0x00: 13822 goto op_semantics_97; 13823 break; 13824 } 13825 break; 13826 case 0xdb: 13827 GETBYTE (); 13828 switch (op[2] & 0x00) 13829 { 13830 case 0x00: 13831 goto op_semantics_97; 13832 break; 13833 } 13834 break; 13835 case 0xdc: 13836 GETBYTE (); 13837 switch (op[2] & 0x00) 13838 { 13839 case 0x00: 13840 goto op_semantics_97; 13841 break; 13842 } 13843 break; 13844 case 0xdd: 13845 GETBYTE (); 13846 switch (op[2] & 0x00) 13847 { 13848 case 0x00: 13849 goto op_semantics_97; 13850 break; 13851 } 13852 break; 13853 case 0xde: 13854 GETBYTE (); 13855 switch (op[2] & 0x00) 13856 { 13857 case 0x00: 13858 goto op_semantics_97; 13859 break; 13860 } 13861 break; 13862 case 0xdf: 13863 GETBYTE (); 13864 switch (op[2] & 0x00) 13865 { 13866 case 0x00: 13867 goto op_semantics_97; 13868 break; 13869 } 13870 break; 13871 case 0xe0: 13872 GETBYTE (); 13873 switch (op[2] & 0x00) 13874 { 13875 case 0x00: 13876 goto op_semantics_97; 13877 break; 13878 } 13879 break; 13880 case 0xe1: 13881 GETBYTE (); 13882 switch (op[2] & 0x00) 13883 { 13884 case 0x00: 13885 goto op_semantics_97; 13886 break; 13887 } 13888 break; 13889 case 0xe2: 13890 GETBYTE (); 13891 switch (op[2] & 0x00) 13892 { 13893 case 0x00: 13894 goto op_semantics_97; 13895 break; 13896 } 13897 break; 13898 case 0xe3: 13899 GETBYTE (); 13900 switch (op[2] & 0x00) 13901 { 13902 case 0x00: 13903 goto op_semantics_97; 13904 break; 13905 } 13906 break; 13907 case 0xe4: 13908 GETBYTE (); 13909 switch (op[2] & 0x00) 13910 { 13911 case 0x00: 13912 goto op_semantics_97; 13913 break; 13914 } 13915 break; 13916 case 0xe5: 13917 GETBYTE (); 13918 switch (op[2] & 0x00) 13919 { 13920 case 0x00: 13921 goto op_semantics_97; 13922 break; 13923 } 13924 break; 13925 case 0xe6: 13926 GETBYTE (); 13927 switch (op[2] & 0x00) 13928 { 13929 case 0x00: 13930 goto op_semantics_97; 13931 break; 13932 } 13933 break; 13934 case 0xe7: 13935 GETBYTE (); 13936 switch (op[2] & 0x00) 13937 { 13938 case 0x00: 13939 goto op_semantics_97; 13940 break; 13941 } 13942 break; 13943 case 0xe8: 13944 GETBYTE (); 13945 switch (op[2] & 0x00) 13946 { 13947 case 0x00: 13948 goto op_semantics_97; 13949 break; 13950 } 13951 break; 13952 case 0xe9: 13953 GETBYTE (); 13954 switch (op[2] & 0x00) 13955 { 13956 case 0x00: 13957 goto op_semantics_97; 13958 break; 13959 } 13960 break; 13961 case 0xea: 13962 GETBYTE (); 13963 switch (op[2] & 0x00) 13964 { 13965 case 0x00: 13966 goto op_semantics_97; 13967 break; 13968 } 13969 break; 13970 case 0xeb: 13971 GETBYTE (); 13972 switch (op[2] & 0x00) 13973 { 13974 case 0x00: 13975 goto op_semantics_97; 13976 break; 13977 } 13978 break; 13979 case 0xec: 13980 GETBYTE (); 13981 switch (op[2] & 0x00) 13982 { 13983 case 0x00: 13984 goto op_semantics_97; 13985 break; 13986 } 13987 break; 13988 case 0xed: 13989 GETBYTE (); 13990 switch (op[2] & 0x00) 13991 { 13992 case 0x00: 13993 goto op_semantics_97; 13994 break; 13995 } 13996 break; 13997 case 0xee: 13998 GETBYTE (); 13999 switch (op[2] & 0x00) 14000 { 14001 case 0x00: 14002 goto op_semantics_97; 14003 break; 14004 } 14005 break; 14006 case 0xef: 14007 GETBYTE (); 14008 switch (op[2] & 0x00) 14009 { 14010 case 0x00: 14011 goto op_semantics_97; 14012 break; 14013 } 14014 break; 14015 default: UNSUPPORTED(); break; 14016 } 14017 break; 14018 case 0xff: 14019 GETBYTE (); 14020 switch (op[1] & 0xff) 14021 { 14022 case 0x00: 14023 GETBYTE (); 14024 switch (op[2] & 0x00) 14025 { 14026 case 0x00: 14027 op_semantics_98: 14028 { 14029 /** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */ 14030 #line 542 "rx-decode.opc" 14031 int rdst AU = op[1] & 0x0f; 14032 #line 542 "rx-decode.opc" 14033 int srca AU = (op[2] >> 4) & 0x0f; 14034 #line 542 "rx-decode.opc" 14035 int srcb AU = op[2] & 0x0f; 14036 if (trace) 14037 { 14038 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 14039 "/** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */", 14040 op[0], op[1], op[2]); 14041 printf (" rdst = 0x%x,", rdst); 14042 printf (" srca = 0x%x,", srca); 14043 printf (" srcb = 0x%x\n", srcb); 14044 } 14045 SYNTAX("sub %2, %1, %0"); 14046 #line 542 "rx-decode.opc" 14047 ID(sub); DR(rdst); SR(srcb); S2R(srca); F_OSZC; 14048 14049 /*----------------------------------------------------------------------*/ 14050 /* SBB */ 14051 14052 } 14053 break; 14054 } 14055 break; 14056 case 0x01: 14057 GETBYTE (); 14058 switch (op[2] & 0x00) 14059 { 14060 case 0x00: 14061 goto op_semantics_98; 14062 break; 14063 } 14064 break; 14065 case 0x02: 14066 GETBYTE (); 14067 switch (op[2] & 0x00) 14068 { 14069 case 0x00: 14070 goto op_semantics_98; 14071 break; 14072 } 14073 break; 14074 case 0x03: 14075 GETBYTE (); 14076 switch (op[2] & 0x00) 14077 { 14078 case 0x00: 14079 goto op_semantics_98; 14080 break; 14081 } 14082 break; 14083 case 0x04: 14084 GETBYTE (); 14085 switch (op[2] & 0x00) 14086 { 14087 case 0x00: 14088 goto op_semantics_98; 14089 break; 14090 } 14091 break; 14092 case 0x05: 14093 GETBYTE (); 14094 switch (op[2] & 0x00) 14095 { 14096 case 0x00: 14097 goto op_semantics_98; 14098 break; 14099 } 14100 break; 14101 case 0x06: 14102 GETBYTE (); 14103 switch (op[2] & 0x00) 14104 { 14105 case 0x00: 14106 goto op_semantics_98; 14107 break; 14108 } 14109 break; 14110 case 0x07: 14111 GETBYTE (); 14112 switch (op[2] & 0x00) 14113 { 14114 case 0x00: 14115 goto op_semantics_98; 14116 break; 14117 } 14118 break; 14119 case 0x08: 14120 GETBYTE (); 14121 switch (op[2] & 0x00) 14122 { 14123 case 0x00: 14124 goto op_semantics_98; 14125 break; 14126 } 14127 break; 14128 case 0x09: 14129 GETBYTE (); 14130 switch (op[2] & 0x00) 14131 { 14132 case 0x00: 14133 goto op_semantics_98; 14134 break; 14135 } 14136 break; 14137 case 0x0a: 14138 GETBYTE (); 14139 switch (op[2] & 0x00) 14140 { 14141 case 0x00: 14142 goto op_semantics_98; 14143 break; 14144 } 14145 break; 14146 case 0x0b: 14147 GETBYTE (); 14148 switch (op[2] & 0x00) 14149 { 14150 case 0x00: 14151 goto op_semantics_98; 14152 break; 14153 } 14154 break; 14155 case 0x0c: 14156 GETBYTE (); 14157 switch (op[2] & 0x00) 14158 { 14159 case 0x00: 14160 goto op_semantics_98; 14161 break; 14162 } 14163 break; 14164 case 0x0d: 14165 GETBYTE (); 14166 switch (op[2] & 0x00) 14167 { 14168 case 0x00: 14169 goto op_semantics_98; 14170 break; 14171 } 14172 break; 14173 case 0x0e: 14174 GETBYTE (); 14175 switch (op[2] & 0x00) 14176 { 14177 case 0x00: 14178 goto op_semantics_98; 14179 break; 14180 } 14181 break; 14182 case 0x0f: 14183 GETBYTE (); 14184 switch (op[2] & 0x00) 14185 { 14186 case 0x00: 14187 goto op_semantics_98; 14188 break; 14189 } 14190 break; 14191 case 0x20: 14192 GETBYTE (); 14193 switch (op[2] & 0x00) 14194 { 14195 case 0x00: 14196 op_semantics_99: 14197 { 14198 /** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */ 14199 #line 509 "rx-decode.opc" 14200 int rdst AU = op[1] & 0x0f; 14201 #line 509 "rx-decode.opc" 14202 int srca AU = (op[2] >> 4) & 0x0f; 14203 #line 509 "rx-decode.opc" 14204 int srcb AU = op[2] & 0x0f; 14205 if (trace) 14206 { 14207 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 14208 "/** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */", 14209 op[0], op[1], op[2]); 14210 printf (" rdst = 0x%x,", rdst); 14211 printf (" srca = 0x%x,", srca); 14212 printf (" srcb = 0x%x\n", srcb); 14213 } 14214 SYNTAX("add %2, %1, %0"); 14215 #line 509 "rx-decode.opc" 14216 ID(add); DR(rdst); SR(srcb); S2R(srca); F_OSZC; 14217 14218 /*----------------------------------------------------------------------*/ 14219 /* CMP */ 14220 14221 } 14222 break; 14223 } 14224 break; 14225 case 0x21: 14226 GETBYTE (); 14227 switch (op[2] & 0x00) 14228 { 14229 case 0x00: 14230 goto op_semantics_99; 14231 break; 14232 } 14233 break; 14234 case 0x22: 14235 GETBYTE (); 14236 switch (op[2] & 0x00) 14237 { 14238 case 0x00: 14239 goto op_semantics_99; 14240 break; 14241 } 14242 break; 14243 case 0x23: 14244 GETBYTE (); 14245 switch (op[2] & 0x00) 14246 { 14247 case 0x00: 14248 goto op_semantics_99; 14249 break; 14250 } 14251 break; 14252 case 0x24: 14253 GETBYTE (); 14254 switch (op[2] & 0x00) 14255 { 14256 case 0x00: 14257 goto op_semantics_99; 14258 break; 14259 } 14260 break; 14261 case 0x25: 14262 GETBYTE (); 14263 switch (op[2] & 0x00) 14264 { 14265 case 0x00: 14266 goto op_semantics_99; 14267 break; 14268 } 14269 break; 14270 case 0x26: 14271 GETBYTE (); 14272 switch (op[2] & 0x00) 14273 { 14274 case 0x00: 14275 goto op_semantics_99; 14276 break; 14277 } 14278 break; 14279 case 0x27: 14280 GETBYTE (); 14281 switch (op[2] & 0x00) 14282 { 14283 case 0x00: 14284 goto op_semantics_99; 14285 break; 14286 } 14287 break; 14288 case 0x28: 14289 GETBYTE (); 14290 switch (op[2] & 0x00) 14291 { 14292 case 0x00: 14293 goto op_semantics_99; 14294 break; 14295 } 14296 break; 14297 case 0x29: 14298 GETBYTE (); 14299 switch (op[2] & 0x00) 14300 { 14301 case 0x00: 14302 goto op_semantics_99; 14303 break; 14304 } 14305 break; 14306 case 0x2a: 14307 GETBYTE (); 14308 switch (op[2] & 0x00) 14309 { 14310 case 0x00: 14311 goto op_semantics_99; 14312 break; 14313 } 14314 break; 14315 case 0x2b: 14316 GETBYTE (); 14317 switch (op[2] & 0x00) 14318 { 14319 case 0x00: 14320 goto op_semantics_99; 14321 break; 14322 } 14323 break; 14324 case 0x2c: 14325 GETBYTE (); 14326 switch (op[2] & 0x00) 14327 { 14328 case 0x00: 14329 goto op_semantics_99; 14330 break; 14331 } 14332 break; 14333 case 0x2d: 14334 GETBYTE (); 14335 switch (op[2] & 0x00) 14336 { 14337 case 0x00: 14338 goto op_semantics_99; 14339 break; 14340 } 14341 break; 14342 case 0x2e: 14343 GETBYTE (); 14344 switch (op[2] & 0x00) 14345 { 14346 case 0x00: 14347 goto op_semantics_99; 14348 break; 14349 } 14350 break; 14351 case 0x2f: 14352 GETBYTE (); 14353 switch (op[2] & 0x00) 14354 { 14355 case 0x00: 14356 goto op_semantics_99; 14357 break; 14358 } 14359 break; 14360 case 0x30: 14361 GETBYTE (); 14362 switch (op[2] & 0x00) 14363 { 14364 case 0x00: 14365 op_semantics_100: 14366 { 14367 /** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */ 14368 #line 611 "rx-decode.opc" 14369 int rdst AU = op[1] & 0x0f; 14370 #line 611 "rx-decode.opc" 14371 int srca AU = (op[2] >> 4) & 0x0f; 14372 #line 611 "rx-decode.opc" 14373 int srcb AU = op[2] & 0x0f; 14374 if (trace) 14375 { 14376 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 14377 "/** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */", 14378 op[0], op[1], op[2]); 14379 printf (" rdst = 0x%x,", rdst); 14380 printf (" srca = 0x%x,", srca); 14381 printf (" srcb = 0x%x\n", srcb); 14382 } 14383 SYNTAX("mul %2, %1, %0"); 14384 #line 611 "rx-decode.opc" 14385 ID(mul); DR(rdst); SR(srcb); S2R(srca); F_____; 14386 14387 /*----------------------------------------------------------------------*/ 14388 /* EMUL */ 14389 14390 } 14391 break; 14392 } 14393 break; 14394 case 0x31: 14395 GETBYTE (); 14396 switch (op[2] & 0x00) 14397 { 14398 case 0x00: 14399 goto op_semantics_100; 14400 break; 14401 } 14402 break; 14403 case 0x32: 14404 GETBYTE (); 14405 switch (op[2] & 0x00) 14406 { 14407 case 0x00: 14408 goto op_semantics_100; 14409 break; 14410 } 14411 break; 14412 case 0x33: 14413 GETBYTE (); 14414 switch (op[2] & 0x00) 14415 { 14416 case 0x00: 14417 goto op_semantics_100; 14418 break; 14419 } 14420 break; 14421 case 0x34: 14422 GETBYTE (); 14423 switch (op[2] & 0x00) 14424 { 14425 case 0x00: 14426 goto op_semantics_100; 14427 break; 14428 } 14429 break; 14430 case 0x35: 14431 GETBYTE (); 14432 switch (op[2] & 0x00) 14433 { 14434 case 0x00: 14435 goto op_semantics_100; 14436 break; 14437 } 14438 break; 14439 case 0x36: 14440 GETBYTE (); 14441 switch (op[2] & 0x00) 14442 { 14443 case 0x00: 14444 goto op_semantics_100; 14445 break; 14446 } 14447 break; 14448 case 0x37: 14449 GETBYTE (); 14450 switch (op[2] & 0x00) 14451 { 14452 case 0x00: 14453 goto op_semantics_100; 14454 break; 14455 } 14456 break; 14457 case 0x38: 14458 GETBYTE (); 14459 switch (op[2] & 0x00) 14460 { 14461 case 0x00: 14462 goto op_semantics_100; 14463 break; 14464 } 14465 break; 14466 case 0x39: 14467 GETBYTE (); 14468 switch (op[2] & 0x00) 14469 { 14470 case 0x00: 14471 goto op_semantics_100; 14472 break; 14473 } 14474 break; 14475 case 0x3a: 14476 GETBYTE (); 14477 switch (op[2] & 0x00) 14478 { 14479 case 0x00: 14480 goto op_semantics_100; 14481 break; 14482 } 14483 break; 14484 case 0x3b: 14485 GETBYTE (); 14486 switch (op[2] & 0x00) 14487 { 14488 case 0x00: 14489 goto op_semantics_100; 14490 break; 14491 } 14492 break; 14493 case 0x3c: 14494 GETBYTE (); 14495 switch (op[2] & 0x00) 14496 { 14497 case 0x00: 14498 goto op_semantics_100; 14499 break; 14500 } 14501 break; 14502 case 0x3d: 14503 GETBYTE (); 14504 switch (op[2] & 0x00) 14505 { 14506 case 0x00: 14507 goto op_semantics_100; 14508 break; 14509 } 14510 break; 14511 case 0x3e: 14512 GETBYTE (); 14513 switch (op[2] & 0x00) 14514 { 14515 case 0x00: 14516 goto op_semantics_100; 14517 break; 14518 } 14519 break; 14520 case 0x3f: 14521 GETBYTE (); 14522 switch (op[2] & 0x00) 14523 { 14524 case 0x00: 14525 goto op_semantics_100; 14526 break; 14527 } 14528 break; 14529 case 0x40: 14530 GETBYTE (); 14531 switch (op[2] & 0x00) 14532 { 14533 case 0x00: 14534 op_semantics_101: 14535 { 14536 /** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */ 14537 #line 419 "rx-decode.opc" 14538 int rdst AU = op[1] & 0x0f; 14539 #line 419 "rx-decode.opc" 14540 int srca AU = (op[2] >> 4) & 0x0f; 14541 #line 419 "rx-decode.opc" 14542 int srcb AU = op[2] & 0x0f; 14543 if (trace) 14544 { 14545 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 14546 "/** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */", 14547 op[0], op[1], op[2]); 14548 printf (" rdst = 0x%x,", rdst); 14549 printf (" srca = 0x%x,", srca); 14550 printf (" srcb = 0x%x\n", srcb); 14551 } 14552 SYNTAX("and %2, %1, %0"); 14553 #line 419 "rx-decode.opc" 14554 ID(and); DR(rdst); SR(srcb); S2R(srca); F__SZ_; 14555 14556 /*----------------------------------------------------------------------*/ 14557 /* OR */ 14558 14559 } 14560 break; 14561 } 14562 break; 14563 case 0x41: 14564 GETBYTE (); 14565 switch (op[2] & 0x00) 14566 { 14567 case 0x00: 14568 goto op_semantics_101; 14569 break; 14570 } 14571 break; 14572 case 0x42: 14573 GETBYTE (); 14574 switch (op[2] & 0x00) 14575 { 14576 case 0x00: 14577 goto op_semantics_101; 14578 break; 14579 } 14580 break; 14581 case 0x43: 14582 GETBYTE (); 14583 switch (op[2] & 0x00) 14584 { 14585 case 0x00: 14586 goto op_semantics_101; 14587 break; 14588 } 14589 break; 14590 case 0x44: 14591 GETBYTE (); 14592 switch (op[2] & 0x00) 14593 { 14594 case 0x00: 14595 goto op_semantics_101; 14596 break; 14597 } 14598 break; 14599 case 0x45: 14600 GETBYTE (); 14601 switch (op[2] & 0x00) 14602 { 14603 case 0x00: 14604 goto op_semantics_101; 14605 break; 14606 } 14607 break; 14608 case 0x46: 14609 GETBYTE (); 14610 switch (op[2] & 0x00) 14611 { 14612 case 0x00: 14613 goto op_semantics_101; 14614 break; 14615 } 14616 break; 14617 case 0x47: 14618 GETBYTE (); 14619 switch (op[2] & 0x00) 14620 { 14621 case 0x00: 14622 goto op_semantics_101; 14623 break; 14624 } 14625 break; 14626 case 0x48: 14627 GETBYTE (); 14628 switch (op[2] & 0x00) 14629 { 14630 case 0x00: 14631 goto op_semantics_101; 14632 break; 14633 } 14634 break; 14635 case 0x49: 14636 GETBYTE (); 14637 switch (op[2] & 0x00) 14638 { 14639 case 0x00: 14640 goto op_semantics_101; 14641 break; 14642 } 14643 break; 14644 case 0x4a: 14645 GETBYTE (); 14646 switch (op[2] & 0x00) 14647 { 14648 case 0x00: 14649 goto op_semantics_101; 14650 break; 14651 } 14652 break; 14653 case 0x4b: 14654 GETBYTE (); 14655 switch (op[2] & 0x00) 14656 { 14657 case 0x00: 14658 goto op_semantics_101; 14659 break; 14660 } 14661 break; 14662 case 0x4c: 14663 GETBYTE (); 14664 switch (op[2] & 0x00) 14665 { 14666 case 0x00: 14667 goto op_semantics_101; 14668 break; 14669 } 14670 break; 14671 case 0x4d: 14672 GETBYTE (); 14673 switch (op[2] & 0x00) 14674 { 14675 case 0x00: 14676 goto op_semantics_101; 14677 break; 14678 } 14679 break; 14680 case 0x4e: 14681 GETBYTE (); 14682 switch (op[2] & 0x00) 14683 { 14684 case 0x00: 14685 goto op_semantics_101; 14686 break; 14687 } 14688 break; 14689 case 0x4f: 14690 GETBYTE (); 14691 switch (op[2] & 0x00) 14692 { 14693 case 0x00: 14694 goto op_semantics_101; 14695 break; 14696 } 14697 break; 14698 case 0x50: 14699 GETBYTE (); 14700 switch (op[2] & 0x00) 14701 { 14702 case 0x00: 14703 op_semantics_102: 14704 { 14705 /** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */ 14706 #line 437 "rx-decode.opc" 14707 int rdst AU = op[1] & 0x0f; 14708 #line 437 "rx-decode.opc" 14709 int srca AU = (op[2] >> 4) & 0x0f; 14710 #line 437 "rx-decode.opc" 14711 int srcb AU = op[2] & 0x0f; 14712 if (trace) 14713 { 14714 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 14715 "/** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */", 14716 op[0], op[1], op[2]); 14717 printf (" rdst = 0x%x,", rdst); 14718 printf (" srca = 0x%x,", srca); 14719 printf (" srcb = 0x%x\n", srcb); 14720 } 14721 SYNTAX("or %2, %1, %0"); 14722 #line 437 "rx-decode.opc" 14723 ID(or); DR(rdst); SR(srcb); S2R(srca); F__SZ_; 14724 14725 /*----------------------------------------------------------------------*/ 14726 /* XOR */ 14727 14728 } 14729 break; 14730 } 14731 break; 14732 case 0x51: 14733 GETBYTE (); 14734 switch (op[2] & 0x00) 14735 { 14736 case 0x00: 14737 goto op_semantics_102; 14738 break; 14739 } 14740 break; 14741 case 0x52: 14742 GETBYTE (); 14743 switch (op[2] & 0x00) 14744 { 14745 case 0x00: 14746 goto op_semantics_102; 14747 break; 14748 } 14749 break; 14750 case 0x53: 14751 GETBYTE (); 14752 switch (op[2] & 0x00) 14753 { 14754 case 0x00: 14755 goto op_semantics_102; 14756 break; 14757 } 14758 break; 14759 case 0x54: 14760 GETBYTE (); 14761 switch (op[2] & 0x00) 14762 { 14763 case 0x00: 14764 goto op_semantics_102; 14765 break; 14766 } 14767 break; 14768 case 0x55: 14769 GETBYTE (); 14770 switch (op[2] & 0x00) 14771 { 14772 case 0x00: 14773 goto op_semantics_102; 14774 break; 14775 } 14776 break; 14777 case 0x56: 14778 GETBYTE (); 14779 switch (op[2] & 0x00) 14780 { 14781 case 0x00: 14782 goto op_semantics_102; 14783 break; 14784 } 14785 break; 14786 case 0x57: 14787 GETBYTE (); 14788 switch (op[2] & 0x00) 14789 { 14790 case 0x00: 14791 goto op_semantics_102; 14792 break; 14793 } 14794 break; 14795 case 0x58: 14796 GETBYTE (); 14797 switch (op[2] & 0x00) 14798 { 14799 case 0x00: 14800 goto op_semantics_102; 14801 break; 14802 } 14803 break; 14804 case 0x59: 14805 GETBYTE (); 14806 switch (op[2] & 0x00) 14807 { 14808 case 0x00: 14809 goto op_semantics_102; 14810 break; 14811 } 14812 break; 14813 case 0x5a: 14814 GETBYTE (); 14815 switch (op[2] & 0x00) 14816 { 14817 case 0x00: 14818 goto op_semantics_102; 14819 break; 14820 } 14821 break; 14822 case 0x5b: 14823 GETBYTE (); 14824 switch (op[2] & 0x00) 14825 { 14826 case 0x00: 14827 goto op_semantics_102; 14828 break; 14829 } 14830 break; 14831 case 0x5c: 14832 GETBYTE (); 14833 switch (op[2] & 0x00) 14834 { 14835 case 0x00: 14836 goto op_semantics_102; 14837 break; 14838 } 14839 break; 14840 case 0x5d: 14841 GETBYTE (); 14842 switch (op[2] & 0x00) 14843 { 14844 case 0x00: 14845 goto op_semantics_102; 14846 break; 14847 } 14848 break; 14849 case 0x5e: 14850 GETBYTE (); 14851 switch (op[2] & 0x00) 14852 { 14853 case 0x00: 14854 goto op_semantics_102; 14855 break; 14856 } 14857 break; 14858 case 0x5f: 14859 GETBYTE (); 14860 switch (op[2] & 0x00) 14861 { 14862 case 0x00: 14863 goto op_semantics_102; 14864 break; 14865 } 14866 break; 14867 default: UNSUPPORTED(); break; 14868 } 14869 break; 14870 default: UNSUPPORTED(); break; 14871 } 14872 #line 1002 "rx-decode.opc" 14873 14874 return rx->n_bytes; 14875 } 14876
Indexes created Wed Mar 25 00:23:37 UTC 2026