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