rx-decode.c revision 1.1.1.6
1 /* DO NOT EDIT! -*- buffer-read-only: t -*- vi:set ro: */ 2 #line 1 "rx-decode.opc" 3 /* -*- c -*- */ 4 /* Copyright (C) 2012-2020 Free Software Foundation, Inc. 5 Contributed by Red Hat. 6 Written by DJ Delorie. 7 8 This file is part of the GNU opcodes library. 9 10 This library is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 3, or (at your option) 13 any later version. 14 15 It is distributed in the hope that it will be useful, but WITHOUT 16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 17 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public 18 License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with this program; if not, write to the Free Software 22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 23 MA 02110-1301, USA. */ 24 25 #include "sysdep.h" 26 #include <stdio.h> 27 #include <stdlib.h> 28 #include <string.h> 29 #include "ansidecl.h" 30 #include "opcode/rx.h" 31 #include "libiberty.h" 32 33 #define RX_OPCODE_BIG_ENDIAN 0 34 35 typedef struct 36 { 37 RX_Opcode_Decoded * rx; 38 int (* getbyte)(void *); 39 void * ptr; 40 unsigned char * op; 41 } LocalData; 42 43 static int trace = 0; 44 45 #define BSIZE 0 46 #define WSIZE 1 47 #define LSIZE 2 48 #define DSIZE 3 49 50 /* These are for when the upper bits are "don't care" or "undefined". */ 51 static int bwl[4] = 52 { 53 RX_Byte, 54 RX_Word, 55 RX_Long, 56 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */ 57 }; 58 59 static int sbwl[4] = 60 { 61 RX_SByte, 62 RX_SWord, 63 RX_Long, 64 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */ 65 }; 66 67 static int ubw[4] = 68 { 69 RX_UByte, 70 RX_UWord, 71 RX_Bad_Size,/* Bogus instructions can have a size field set to 2. */ 72 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */ 73 }; 74 75 static int memex[4] = 76 { 77 RX_SByte, 78 RX_SWord, 79 RX_Long, 80 RX_UWord 81 }; 82 83 static int _ld[2] = 84 { 85 RX_Long, 86 RX_Double 87 }; 88 89 #define ID(x) rx->id = RXO_##x 90 #define OP(n,t,r,a) (rx->op[n].type = t, \ 91 rx->op[n].reg = r, \ 92 rx->op[n].addend = a ) 93 #define OPs(n,t,r,a,s) (OP (n,t,r,a), \ 94 rx->op[n].size = s ) 95 96 /* This is for the BWL and BW bitfields. */ 97 static int SCALE[] = { 1, 2, 4, 0 }; 98 /* This is for the prefix size enum. */ 99 static int PSCALE[] = { 4, 1, 1, 1, 2, 2, 2, 3, 4, 8 }; 100 101 #define GET_SCALE(_indx) ((unsigned)(_indx) < ARRAY_SIZE (SCALE) ? SCALE[(_indx)] : 0) 102 #define GET_PSCALE(_indx) ((unsigned)(_indx) < ARRAY_SIZE (PSCALE) ? PSCALE[(_indx)] : 0) 103 104 static int flagmap[] = {0, 1, 2, 3, 0, 0, 0, 0, 105 16, 17, 0, 0, 0, 0, 0, 0 }; 106 107 static int dsp3map[] = { 8, 9, 10, 3, 4, 5, 6, 7 }; 108 109 /* 110 *C a constant (immediate) c 111 *R A register 112 *I Register indirect, no offset 113 *Is Register indirect, with offset 114 *D standard displacement: type (r,[r],dsp8,dsp16 code), register, BWL code 115 *P standard displacement: type (r,[r]), reg, assumes UByte 116 *Pm memex displacement: type (r,[r]), reg, memex code 117 *cc condition code. */ 118 119 #define DC(c) OP (0, RX_Operand_Immediate, 0, c) 120 #define DR(r) OP (0, RX_Operand_Register, r, 0) 121 #define DI(r,a) OP (0, RX_Operand_Indirect, r, a) 122 #define DIs(r,a,s) OP (0, RX_Operand_Indirect, r, (a) * GET_SCALE (s)) 123 #define DD(t,r,s) rx_disp (0, t, r, bwl[s], ld); 124 #define DF(r) OP (0, RX_Operand_Flag, flagmap[r], 0) 125 #define DCR(r) OP (0, RX_Operand_DoubleCReg, r, 0) 126 #define DDR(r) OP (0, RX_Operand_DoubleReg, r, 0) 127 #define DDRH(r) OP (0, RX_Operand_DoubleRegH, r, 0) 128 #define DDRL(r) OP (0, RX_Operand_DoubleRegL, r, 0) 129 #define DCND(r) OP (0, RX_Operand_DoubleCond, r, 0) 130 131 #define SC(i) OP (1, RX_Operand_Immediate, 0, i) 132 #define SR(r) OP (1, RX_Operand_Register, r, 0) 133 #define SRR(r) OP (1, RX_Operand_TwoReg, r, 0) 134 #define SI(r,a) OP (1, RX_Operand_Indirect, r, a) 135 #define SIs(r,a,s) OP (1, RX_Operand_Indirect, r, (a) * GET_SCALE (s)) 136 #define SD(t,r,s) rx_disp (1, t, r, bwl[s], ld); 137 #define SP(t,r) rx_disp (1, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 1); 138 #define SPm(t,r,m) rx_disp (1, t, r, memex[m], ld); rx->op[1].size = memex[m]; 139 #define Scc(cc) OP (1, RX_Operand_Condition, cc, 0) 140 #define SCR(r) OP (1, RX_Operand_DoubleCReg, r, 0) 141 #define SDR(r) OP (1, RX_Operand_DoubleReg, r, 0) 142 #define SDRH(r) OP (1, RX_Operand_DoubleRegH, r, 0) 143 #define SDRL(r) OP (1, RX_Operand_DoubleRegL, r, 0) 144 145 #define S2C(i) OP (2, RX_Operand_Immediate, 0, i) 146 #define S2R(r) OP (2, RX_Operand_Register, r, 0) 147 #define S2I(r,a) OP (2, RX_Operand_Indirect, r, a) 148 #define S2Is(r,a,s) OP (2, RX_Operand_Indirect, r, (a) * GET_SCALE (s)) 149 #define S2D(t,r,s) rx_disp (2, t, r, bwl[s], ld); 150 #define S2P(t,r) rx_disp (2, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 2); 151 #define S2Pm(t,r,m) rx_disp (2, t, r, memex[m], ld); rx->op[2].size = memex[m]; 152 #define S2cc(cc) OP (2, RX_Operand_Condition, cc, 0) 153 #define S2DR(r) OP (2, RX_Operand_DoubleReg, r, 0) 154 #define S2CR(r) OP (2, RX_Operand_DoubleCReg, r, 0) 155 156 #define SDD(t,r,s) rx_disp (1, t, r, bwl, ld); 157 158 #define BWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = bwl[sz] 159 #define sBWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = sbwl[sz] 160 #define uBW(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = ubw[sz] 161 #define P(t, n) rx->op[n].size = (t!=3) ? RX_UByte : RX_Long; 162 #define DL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = _ld[sz] 163 164 #define F(f) store_flags(rx, f) 165 166 #define AU ATTRIBUTE_UNUSED 167 #define GETBYTE() (ld->op [ld->rx->n_bytes++] = ld->getbyte (ld->ptr)) 168 169 #define SYNTAX(x) rx->syntax = x 170 171 #define UNSUPPORTED() \ 172 rx->syntax = "*unknown*" 173 174 #define IMM(sf) immediate (sf, 0, ld) 175 #define IMMex(sf) immediate (sf, 1, ld) 176 177 static int 178 immediate (int sfield, int ex, LocalData * ld) 179 { 180 unsigned long i = 0, j; 181 182 switch (sfield) 183 { 184 #define B ((unsigned long) GETBYTE()) 185 case 0: 186 #if RX_OPCODE_BIG_ENDIAN 187 i = B; 188 if (ex && (i & 0x80)) 189 i -= 0x100; 190 i <<= 24; 191 i |= B << 16; 192 i |= B << 8; 193 i |= B; 194 #else 195 i = B; 196 i |= B << 8; 197 i |= B << 16; 198 j = B; 199 if (ex && (j & 0x80)) 200 j -= 0x100; 201 i |= j << 24; 202 #endif 203 break; 204 case 3: 205 #if RX_OPCODE_BIG_ENDIAN 206 i = B << 16; 207 i |= B << 8; 208 i |= B; 209 #else 210 i = B; 211 i |= B << 8; 212 i |= B << 16; 213 #endif 214 if (ex && (i & 0x800000)) 215 i -= 0x1000000; 216 break; 217 case 2: 218 #if RX_OPCODE_BIG_ENDIAN 219 i |= B << 8; 220 i |= B; 221 #else 222 i |= B; 223 i |= B << 8; 224 #endif 225 if (ex && (i & 0x8000)) 226 i -= 0x10000; 227 break; 228 case 1: 229 i |= B; 230 if (ex && (i & 0x80)) 231 i -= 0x100; 232 break; 233 default: 234 abort(); 235 } 236 return i; 237 } 238 239 static void 240 rx_disp (int n, int type, int reg, unsigned int size, LocalData * ld) 241 { 242 int disp; 243 244 ld->rx->op[n].reg = reg; 245 switch (type) 246 { 247 case 3: 248 ld->rx->op[n].type = RX_Operand_Register; 249 break; 250 case 0: 251 ld->rx->op[n].type = RX_Operand_Zero_Indirect; 252 ld->rx->op[n].addend = 0; 253 break; 254 case 1: 255 ld->rx->op[n].type = RX_Operand_Indirect; 256 disp = GETBYTE (); 257 ld->rx->op[n].addend = disp * GET_PSCALE (size); 258 break; 259 case 2: 260 ld->rx->op[n].type = RX_Operand_Indirect; 261 disp = GETBYTE (); 262 #if RX_OPCODE_BIG_ENDIAN 263 disp = disp * 256 + GETBYTE (); 264 #else 265 disp = disp + GETBYTE () * 256; 266 #endif 267 ld->rx->op[n].addend = disp * GET_PSCALE (size); 268 break; 269 default: 270 abort (); 271 } 272 } 273 274 #define xO 8 275 #define xS 4 276 #define xZ 2 277 #define xC 1 278 279 #define F_____ 280 #define F___ZC rx->flags_0 = rx->flags_s = xZ|xC; 281 #define F__SZ_ rx->flags_0 = rx->flags_s = xS|xZ; 282 #define F__SZC rx->flags_0 = rx->flags_s = xS|xZ|xC; 283 #define F_0SZC rx->flags_0 = xO|xS|xZ|xC; rx->flags_s = xS|xZ|xC; 284 #define F_O___ rx->flags_0 = rx->flags_s = xO; 285 #define F_OS__ rx->flags_0 = rx->flags_s = xO|xS; 286 #define F_OSZ_ rx->flags_0 = rx->flags_s = xO|xS|xZ; 287 #define F_OSZC rx->flags_0 = rx->flags_s = xO|xS|xZ|xC; 288 289 int 290 rx_decode_opcode (unsigned long pc AU, 291 RX_Opcode_Decoded * rx, 292 int (* getbyte)(void *), 293 void * ptr) 294 { 295 LocalData lds, * ld = &lds; 296 unsigned char op[20] = {0}; 297 298 lds.rx = rx; 299 lds.getbyte = getbyte; 300 lds.ptr = ptr; 301 lds.op = op; 302 303 memset (rx, 0, sizeof (*rx)); 304 BWL(LSIZE); 305 306 307 /*----------------------------------------------------------------------*/ 308 /* MOV */ 309 310 GETBYTE (); 311 switch (op[0] & 0xff) 312 { 313 case 0x00: 314 { 315 /** 0000 0000 brk */ 316 if (trace) 317 { 318 printf ("\033[33m%s\033[0m %02x\n", 319 "/** 0000 0000 brk */", 320 op[0]); 321 } 322 SYNTAX("brk"); 323 #line 1050 "rx-decode.opc" 324 ID(brk); 325 326 } 327 break; 328 case 0x01: 329 { 330 /** 0000 0001 dbt */ 331 if (trace) 332 { 333 printf ("\033[33m%s\033[0m %02x\n", 334 "/** 0000 0001 dbt */", 335 op[0]); 336 } 337 SYNTAX("dbt"); 338 #line 1053 "rx-decode.opc" 339 ID(dbt); 340 341 } 342 break; 343 case 0x02: 344 { 345 /** 0000 0010 rts */ 346 if (trace) 347 { 348 printf ("\033[33m%s\033[0m %02x\n", 349 "/** 0000 0010 rts */", 350 op[0]); 351 } 352 SYNTAX("rts"); 353 #line 831 "rx-decode.opc" 354 ID(rts); 355 356 /*----------------------------------------------------------------------*/ 357 /* NOP */ 358 359 } 360 break; 361 case 0x03: 362 { 363 /** 0000 0011 nop */ 364 if (trace) 365 { 366 printf ("\033[33m%s\033[0m %02x\n", 367 "/** 0000 0011 nop */", 368 op[0]); 369 } 370 SYNTAX("nop"); 371 #line 837 "rx-decode.opc" 372 ID(nop); 373 374 /*----------------------------------------------------------------------*/ 375 /* STRING FUNCTIONS */ 376 377 } 378 break; 379 case 0x04: 380 { 381 /** 0000 0100 bra.a %a0 */ 382 if (trace) 383 { 384 printf ("\033[33m%s\033[0m %02x\n", 385 "/** 0000 0100 bra.a %a0 */", 386 op[0]); 387 } 388 SYNTAX("bra.a %a0"); 389 #line 809 "rx-decode.opc" 390 ID(branch); DC(pc + IMMex(3)); 391 392 } 393 break; 394 case 0x05: 395 { 396 /** 0000 0101 bsr.a %a0 */ 397 if (trace) 398 { 399 printf ("\033[33m%s\033[0m %02x\n", 400 "/** 0000 0101 bsr.a %a0 */", 401 op[0]); 402 } 403 SYNTAX("bsr.a %a0"); 404 #line 825 "rx-decode.opc" 405 ID(jsr); DC(pc + IMMex(3)); 406 407 } 408 break; 409 case 0x06: 410 GETBYTE (); 411 switch (op[1] & 0xff) 412 { 413 case 0x00: 414 GETBYTE (); 415 switch (op[2] & 0x00) 416 { 417 case 0x00: 418 op_semantics_1: 419 { 420 /** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */ 421 #line 567 "rx-decode.opc" 422 int mx AU = (op[1] >> 6) & 0x03; 423 #line 567 "rx-decode.opc" 424 int ss AU = op[1] & 0x03; 425 #line 567 "rx-decode.opc" 426 int rsrc AU = (op[2] >> 4) & 0x0f; 427 #line 567 "rx-decode.opc" 428 int rdst AU = op[2] & 0x0f; 429 if (trace) 430 { 431 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 432 "/** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */", 433 op[0], op[1], op[2]); 434 printf (" mx = 0x%x,", mx); 435 printf (" ss = 0x%x,", ss); 436 printf (" rsrc = 0x%x,", rsrc); 437 printf (" rdst = 0x%x\n", rdst); 438 } 439 SYNTAX("sub %2%S2, %1"); 440 #line 567 "rx-decode.opc" 441 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F_OSZC; 442 443 } 444 break; 445 } 446 break; 447 case 0x01: 448 GETBYTE (); 449 switch (op[2] & 0x00) 450 { 451 case 0x00: 452 goto op_semantics_1; 453 break; 454 } 455 break; 456 case 0x02: 457 GETBYTE (); 458 switch (op[2] & 0x00) 459 { 460 case 0x00: 461 goto op_semantics_1; 462 break; 463 } 464 break; 465 case 0x03: 466 GETBYTE (); 467 switch (op[2] & 0x00) 468 { 469 case 0x00: 470 goto op_semantics_1; 471 break; 472 } 473 break; 474 case 0x04: 475 GETBYTE (); 476 switch (op[2] & 0x00) 477 { 478 case 0x00: 479 op_semantics_2: 480 { 481 /** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */ 482 #line 555 "rx-decode.opc" 483 int mx AU = (op[1] >> 6) & 0x03; 484 #line 555 "rx-decode.opc" 485 int ss AU = op[1] & 0x03; 486 #line 555 "rx-decode.opc" 487 int rsrc AU = (op[2] >> 4) & 0x0f; 488 #line 555 "rx-decode.opc" 489 int rdst AU = op[2] & 0x0f; 490 if (trace) 491 { 492 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 493 "/** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */", 494 op[0], op[1], op[2]); 495 printf (" mx = 0x%x,", mx); 496 printf (" ss = 0x%x,", ss); 497 printf (" rsrc = 0x%x,", rsrc); 498 printf (" rdst = 0x%x\n", rdst); 499 } 500 SYNTAX("cmp %2%S2, %1"); 501 #line 555 "rx-decode.opc" 502 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F_OSZC; 503 504 /*----------------------------------------------------------------------*/ 505 /* SUB */ 506 507 } 508 break; 509 } 510 break; 511 case 0x05: 512 GETBYTE (); 513 switch (op[2] & 0x00) 514 { 515 case 0x00: 516 goto op_semantics_2; 517 break; 518 } 519 break; 520 case 0x06: 521 GETBYTE (); 522 switch (op[2] & 0x00) 523 { 524 case 0x00: 525 goto op_semantics_2; 526 break; 527 } 528 break; 529 case 0x07: 530 GETBYTE (); 531 switch (op[2] & 0x00) 532 { 533 case 0x00: 534 goto op_semantics_2; 535 break; 536 } 537 break; 538 case 0x08: 539 GETBYTE (); 540 switch (op[2] & 0x00) 541 { 542 case 0x00: 543 op_semantics_3: 544 { 545 /** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */ 546 #line 531 "rx-decode.opc" 547 int mx AU = (op[1] >> 6) & 0x03; 548 #line 531 "rx-decode.opc" 549 int ss AU = op[1] & 0x03; 550 #line 531 "rx-decode.opc" 551 int rsrc AU = (op[2] >> 4) & 0x0f; 552 #line 531 "rx-decode.opc" 553 int rdst AU = op[2] & 0x0f; 554 if (trace) 555 { 556 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 557 "/** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */", 558 op[0], op[1], op[2]); 559 printf (" mx = 0x%x,", mx); 560 printf (" ss = 0x%x,", ss); 561 printf (" rsrc = 0x%x,", rsrc); 562 printf (" rdst = 0x%x\n", rdst); 563 } 564 SYNTAX("add %1%S1, %0"); 565 #line 531 "rx-decode.opc" 566 ID(add); SPm(ss, rsrc, mx); DR(rdst); F_OSZC; 567 568 } 569 break; 570 } 571 break; 572 case 0x09: 573 GETBYTE (); 574 switch (op[2] & 0x00) 575 { 576 case 0x00: 577 goto op_semantics_3; 578 break; 579 } 580 break; 581 case 0x0a: 582 GETBYTE (); 583 switch (op[2] & 0x00) 584 { 585 case 0x00: 586 goto op_semantics_3; 587 break; 588 } 589 break; 590 case 0x0b: 591 GETBYTE (); 592 switch (op[2] & 0x00) 593 { 594 case 0x00: 595 goto op_semantics_3; 596 break; 597 } 598 break; 599 case 0x0c: 600 GETBYTE (); 601 switch (op[2] & 0x00) 602 { 603 case 0x00: 604 op_semantics_4: 605 { 606 /** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */ 607 #line 674 "rx-decode.opc" 608 int mx AU = (op[1] >> 6) & 0x03; 609 #line 674 "rx-decode.opc" 610 int ss AU = op[1] & 0x03; 611 #line 674 "rx-decode.opc" 612 int rsrc AU = (op[2] >> 4) & 0x0f; 613 #line 674 "rx-decode.opc" 614 int rdst AU = op[2] & 0x0f; 615 if (trace) 616 { 617 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 618 "/** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */", 619 op[0], op[1], op[2]); 620 printf (" mx = 0x%x,", mx); 621 printf (" ss = 0x%x,", ss); 622 printf (" rsrc = 0x%x,", rsrc); 623 printf (" rdst = 0x%x\n", rdst); 624 } 625 SYNTAX("mul %1%S1, %0"); 626 #line 674 "rx-decode.opc" 627 ID(mul); SPm(ss, rsrc, mx); DR(rdst); F_____; 628 629 } 630 break; 631 } 632 break; 633 case 0x0d: 634 GETBYTE (); 635 switch (op[2] & 0x00) 636 { 637 case 0x00: 638 goto op_semantics_4; 639 break; 640 } 641 break; 642 case 0x0e: 643 GETBYTE (); 644 switch (op[2] & 0x00) 645 { 646 case 0x00: 647 goto op_semantics_4; 648 break; 649 } 650 break; 651 case 0x0f: 652 GETBYTE (); 653 switch (op[2] & 0x00) 654 { 655 case 0x00: 656 goto op_semantics_4; 657 break; 658 } 659 break; 660 case 0x10: 661 GETBYTE (); 662 switch (op[2] & 0x00) 663 { 664 case 0x00: 665 op_semantics_5: 666 { 667 /** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */ 668 #line 444 "rx-decode.opc" 669 int mx AU = (op[1] >> 6) & 0x03; 670 #line 444 "rx-decode.opc" 671 int ss AU = op[1] & 0x03; 672 #line 444 "rx-decode.opc" 673 int rsrc AU = (op[2] >> 4) & 0x0f; 674 #line 444 "rx-decode.opc" 675 int rdst AU = op[2] & 0x0f; 676 if (trace) 677 { 678 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 679 "/** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */", 680 op[0], op[1], op[2]); 681 printf (" mx = 0x%x,", mx); 682 printf (" ss = 0x%x,", ss); 683 printf (" rsrc = 0x%x,", rsrc); 684 printf (" rdst = 0x%x\n", rdst); 685 } 686 SYNTAX("and %1%S1, %0"); 687 #line 444 "rx-decode.opc" 688 ID(and); SPm(ss, rsrc, mx); DR(rdst); F__SZ_; 689 690 } 691 break; 692 } 693 break; 694 case 0x11: 695 GETBYTE (); 696 switch (op[2] & 0x00) 697 { 698 case 0x00: 699 goto op_semantics_5; 700 break; 701 } 702 break; 703 case 0x12: 704 GETBYTE (); 705 switch (op[2] & 0x00) 706 { 707 case 0x00: 708 goto op_semantics_5; 709 break; 710 } 711 break; 712 case 0x13: 713 GETBYTE (); 714 switch (op[2] & 0x00) 715 { 716 case 0x00: 717 goto op_semantics_5; 718 break; 719 } 720 break; 721 case 0x14: 722 GETBYTE (); 723 switch (op[2] & 0x00) 724 { 725 case 0x00: 726 op_semantics_6: 727 { 728 /** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */ 729 #line 462 "rx-decode.opc" 730 int mx AU = (op[1] >> 6) & 0x03; 731 #line 462 "rx-decode.opc" 732 int ss AU = op[1] & 0x03; 733 #line 462 "rx-decode.opc" 734 int rsrc AU = (op[2] >> 4) & 0x0f; 735 #line 462 "rx-decode.opc" 736 int rdst AU = op[2] & 0x0f; 737 if (trace) 738 { 739 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 740 "/** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */", 741 op[0], op[1], op[2]); 742 printf (" mx = 0x%x,", mx); 743 printf (" ss = 0x%x,", ss); 744 printf (" rsrc = 0x%x,", rsrc); 745 printf (" rdst = 0x%x\n", rdst); 746 } 747 SYNTAX("or %1%S1, %0"); 748 #line 462 "rx-decode.opc" 749 ID(or); SPm(ss, rsrc, mx); DR(rdst); F__SZ_; 750 751 } 752 break; 753 } 754 break; 755 case 0x15: 756 GETBYTE (); 757 switch (op[2] & 0x00) 758 { 759 case 0x00: 760 goto op_semantics_6; 761 break; 762 } 763 break; 764 case 0x16: 765 GETBYTE (); 766 switch (op[2] & 0x00) 767 { 768 case 0x00: 769 goto op_semantics_6; 770 break; 771 } 772 break; 773 case 0x17: 774 GETBYTE (); 775 switch (op[2] & 0x00) 776 { 777 case 0x00: 778 goto op_semantics_6; 779 break; 780 } 781 break; 782 case 0x20: 783 GETBYTE (); 784 switch (op[2] & 0xff) 785 { 786 case 0x00: 787 GETBYTE (); 788 switch (op[3] & 0x00) 789 { 790 case 0x00: 791 op_semantics_7: 792 { 793 /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */ 794 #line 580 "rx-decode.opc" 795 int mx AU = (op[1] >> 6) & 0x03; 796 #line 580 "rx-decode.opc" 797 int sp AU = op[1] & 0x03; 798 #line 580 "rx-decode.opc" 799 int rsrc AU = (op[3] >> 4) & 0x0f; 800 #line 580 "rx-decode.opc" 801 int rdst AU = op[3] & 0x0f; 802 if (trace) 803 { 804 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 805 "/** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */", 806 op[0], op[1], op[2], op[3]); 807 printf (" mx = 0x%x,", mx); 808 printf (" sp = 0x%x,", sp); 809 printf (" rsrc = 0x%x,", rsrc); 810 printf (" rdst = 0x%x\n", rdst); 811 } 812 SYNTAX("sbb %1%S1, %0"); 813 #line 580 "rx-decode.opc" 814 ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F_OSZC; 815 816 /*----------------------------------------------------------------------*/ 817 /* ABS */ 818 819 } 820 break; 821 } 822 break; 823 case 0x04: 824 GETBYTE (); 825 switch (op[3] & 0x00) 826 { 827 case 0x00: 828 op_semantics_8: 829 { 830 /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */ 831 #line 619 "rx-decode.opc" 832 int mx AU = (op[1] >> 6) & 0x03; 833 #line 619 "rx-decode.opc" 834 int ss AU = op[1] & 0x03; 835 #line 619 "rx-decode.opc" 836 int rsrc AU = (op[3] >> 4) & 0x0f; 837 #line 619 "rx-decode.opc" 838 int rdst AU = op[3] & 0x0f; 839 if (trace) 840 { 841 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 842 "/** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */", 843 op[0], op[1], op[2], op[3]); 844 printf (" mx = 0x%x,", mx); 845 printf (" ss = 0x%x,", ss); 846 printf (" rsrc = 0x%x,", rsrc); 847 printf (" rdst = 0x%x\n", rdst); 848 } 849 SYNTAX("max %1%S1, %0"); 850 #line 619 "rx-decode.opc" 851 ID(max); SPm(ss, rsrc, mx); DR(rdst); 852 853 /*----------------------------------------------------------------------*/ 854 /* MIN */ 855 856 } 857 break; 858 } 859 break; 860 case 0x05: 861 GETBYTE (); 862 switch (op[3] & 0x00) 863 { 864 case 0x00: 865 op_semantics_9: 866 { 867 /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */ 868 #line 631 "rx-decode.opc" 869 int mx AU = (op[1] >> 6) & 0x03; 870 #line 631 "rx-decode.opc" 871 int ss AU = op[1] & 0x03; 872 #line 631 "rx-decode.opc" 873 int rsrc AU = (op[3] >> 4) & 0x0f; 874 #line 631 "rx-decode.opc" 875 int rdst AU = op[3] & 0x0f; 876 if (trace) 877 { 878 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 879 "/** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */", 880 op[0], op[1], op[2], op[3]); 881 printf (" mx = 0x%x,", mx); 882 printf (" ss = 0x%x,", ss); 883 printf (" rsrc = 0x%x,", rsrc); 884 printf (" rdst = 0x%x\n", rdst); 885 } 886 SYNTAX("min %1%S1, %0"); 887 #line 631 "rx-decode.opc" 888 ID(min); SPm(ss, rsrc, mx); DR(rdst); 889 890 /*----------------------------------------------------------------------*/ 891 /* MUL */ 892 893 } 894 break; 895 } 896 break; 897 case 0x06: 898 GETBYTE (); 899 switch (op[3] & 0x00) 900 { 901 case 0x00: 902 op_semantics_10: 903 { 904 /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */ 905 #line 689 "rx-decode.opc" 906 int mx AU = (op[1] >> 6) & 0x03; 907 #line 689 "rx-decode.opc" 908 int ss AU = op[1] & 0x03; 909 #line 689 "rx-decode.opc" 910 int rsrc AU = (op[3] >> 4) & 0x0f; 911 #line 689 "rx-decode.opc" 912 int rdst AU = op[3] & 0x0f; 913 if (trace) 914 { 915 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 916 "/** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */", 917 op[0], op[1], op[2], op[3]); 918 printf (" mx = 0x%x,", mx); 919 printf (" ss = 0x%x,", ss); 920 printf (" rsrc = 0x%x,", rsrc); 921 printf (" rdst = 0x%x\n", rdst); 922 } 923 SYNTAX("emul %1%S1, %0"); 924 #line 689 "rx-decode.opc" 925 ID(emul); SPm(ss, rsrc, mx); DR(rdst); 926 927 /*----------------------------------------------------------------------*/ 928 /* EMULU */ 929 930 } 931 break; 932 } 933 break; 934 case 0x07: 935 GETBYTE (); 936 switch (op[3] & 0x00) 937 { 938 case 0x00: 939 op_semantics_11: 940 { 941 /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */ 942 #line 701 "rx-decode.opc" 943 int mx AU = (op[1] >> 6) & 0x03; 944 #line 701 "rx-decode.opc" 945 int ss AU = op[1] & 0x03; 946 #line 701 "rx-decode.opc" 947 int rsrc AU = (op[3] >> 4) & 0x0f; 948 #line 701 "rx-decode.opc" 949 int rdst AU = op[3] & 0x0f; 950 if (trace) 951 { 952 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 953 "/** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */", 954 op[0], op[1], op[2], op[3]); 955 printf (" mx = 0x%x,", mx); 956 printf (" ss = 0x%x,", ss); 957 printf (" rsrc = 0x%x,", rsrc); 958 printf (" rdst = 0x%x\n", rdst); 959 } 960 SYNTAX("emulu %1%S1, %0"); 961 #line 701 "rx-decode.opc" 962 ID(emulu); SPm(ss, rsrc, mx); DR(rdst); 963 964 /*----------------------------------------------------------------------*/ 965 /* DIV */ 966 967 } 968 break; 969 } 970 break; 971 case 0x08: 972 GETBYTE (); 973 switch (op[3] & 0x00) 974 { 975 case 0x00: 976 op_semantics_12: 977 { 978 /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */ 979 #line 713 "rx-decode.opc" 980 int mx AU = (op[1] >> 6) & 0x03; 981 #line 713 "rx-decode.opc" 982 int ss AU = op[1] & 0x03; 983 #line 713 "rx-decode.opc" 984 int rsrc AU = (op[3] >> 4) & 0x0f; 985 #line 713 "rx-decode.opc" 986 int rdst AU = op[3] & 0x0f; 987 if (trace) 988 { 989 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 990 "/** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */", 991 op[0], op[1], op[2], op[3]); 992 printf (" mx = 0x%x,", mx); 993 printf (" ss = 0x%x,", ss); 994 printf (" rsrc = 0x%x,", rsrc); 995 printf (" rdst = 0x%x\n", rdst); 996 } 997 SYNTAX("div %1%S1, %0"); 998 #line 713 "rx-decode.opc" 999 ID(div); SPm(ss, rsrc, mx); DR(rdst); F_O___; 1000 1001 /*----------------------------------------------------------------------*/ 1002 /* DIVU */ 1003 1004 } 1005 break; 1006 } 1007 break; 1008 case 0x09: 1009 GETBYTE (); 1010 switch (op[3] & 0x00) 1011 { 1012 case 0x00: 1013 op_semantics_13: 1014 { 1015 /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */ 1016 #line 725 "rx-decode.opc" 1017 int mx AU = (op[1] >> 6) & 0x03; 1018 #line 725 "rx-decode.opc" 1019 int ss AU = op[1] & 0x03; 1020 #line 725 "rx-decode.opc" 1021 int rsrc AU = (op[3] >> 4) & 0x0f; 1022 #line 725 "rx-decode.opc" 1023 int rdst AU = op[3] & 0x0f; 1024 if (trace) 1025 { 1026 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 1027 "/** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */", 1028 op[0], op[1], op[2], op[3]); 1029 printf (" mx = 0x%x,", mx); 1030 printf (" ss = 0x%x,", ss); 1031 printf (" rsrc = 0x%x,", rsrc); 1032 printf (" rdst = 0x%x\n", rdst); 1033 } 1034 SYNTAX("divu %1%S1, %0"); 1035 #line 725 "rx-decode.opc" 1036 ID(divu); SPm(ss, rsrc, mx); DR(rdst); F_O___; 1037 1038 /*----------------------------------------------------------------------*/ 1039 /* SHIFT */ 1040 1041 } 1042 break; 1043 } 1044 break; 1045 case 0x0c: 1046 GETBYTE (); 1047 switch (op[3] & 0x00) 1048 { 1049 case 0x00: 1050 op_semantics_14: 1051 { 1052 /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */ 1053 #line 498 "rx-decode.opc" 1054 int mx AU = (op[1] >> 6) & 0x03; 1055 #line 498 "rx-decode.opc" 1056 int ss AU = op[1] & 0x03; 1057 #line 498 "rx-decode.opc" 1058 int rsrc AU = (op[3] >> 4) & 0x0f; 1059 #line 498 "rx-decode.opc" 1060 int rdst AU = op[3] & 0x0f; 1061 if (trace) 1062 { 1063 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 1064 "/** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */", 1065 op[0], op[1], op[2], op[3]); 1066 printf (" mx = 0x%x,", mx); 1067 printf (" ss = 0x%x,", ss); 1068 printf (" rsrc = 0x%x,", rsrc); 1069 printf (" rdst = 0x%x\n", rdst); 1070 } 1071 SYNTAX("tst %1%S1, %2"); 1072 #line 498 "rx-decode.opc" 1073 ID(and); SPm(ss, rsrc, mx); S2R(rdst); F__SZ_; 1074 1075 /*----------------------------------------------------------------------*/ 1076 /* NEG */ 1077 1078 } 1079 break; 1080 } 1081 break; 1082 case 0x0d: 1083 GETBYTE (); 1084 switch (op[3] & 0x00) 1085 { 1086 case 0x00: 1087 op_semantics_15: 1088 { 1089 /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */ 1090 #line 477 "rx-decode.opc" 1091 int mx AU = (op[1] >> 6) & 0x03; 1092 #line 477 "rx-decode.opc" 1093 int ss AU = op[1] & 0x03; 1094 #line 477 "rx-decode.opc" 1095 int rsrc AU = (op[3] >> 4) & 0x0f; 1096 #line 477 "rx-decode.opc" 1097 int rdst AU = op[3] & 0x0f; 1098 if (trace) 1099 { 1100 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 1101 "/** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */", 1102 op[0], op[1], op[2], op[3]); 1103 printf (" mx = 0x%x,", mx); 1104 printf (" ss = 0x%x,", ss); 1105 printf (" rsrc = 0x%x,", rsrc); 1106 printf (" rdst = 0x%x\n", rdst); 1107 } 1108 SYNTAX("xor %1%S1, %0"); 1109 #line 477 "rx-decode.opc" 1110 ID(xor); SPm(ss, rsrc, mx); DR(rdst); F__SZ_; 1111 1112 /*----------------------------------------------------------------------*/ 1113 /* NOT */ 1114 1115 } 1116 break; 1117 } 1118 break; 1119 case 0x10: 1120 GETBYTE (); 1121 switch (op[3] & 0x00) 1122 { 1123 case 0x00: 1124 op_semantics_16: 1125 { 1126 /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */ 1127 #line 411 "rx-decode.opc" 1128 int mx AU = (op[1] >> 6) & 0x03; 1129 #line 411 "rx-decode.opc" 1130 int ss AU = op[1] & 0x03; 1131 #line 411 "rx-decode.opc" 1132 int rsrc AU = (op[3] >> 4) & 0x0f; 1133 #line 411 "rx-decode.opc" 1134 int rdst AU = op[3] & 0x0f; 1135 if (trace) 1136 { 1137 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 1138 "/** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */", 1139 op[0], op[1], op[2], op[3]); 1140 printf (" mx = 0x%x,", mx); 1141 printf (" ss = 0x%x,", ss); 1142 printf (" rsrc = 0x%x,", rsrc); 1143 printf (" rdst = 0x%x\n", rdst); 1144 } 1145 SYNTAX("xchg %1%S1, %0"); 1146 #line 411 "rx-decode.opc" 1147 ID(xchg); DR(rdst); SPm(ss, rsrc, mx); 1148 1149 /*----------------------------------------------------------------------*/ 1150 /* STZ/STNZ */ 1151 1152 } 1153 break; 1154 } 1155 break; 1156 case 0x11: 1157 GETBYTE (); 1158 switch (op[3] & 0x00) 1159 { 1160 case 0x00: 1161 op_semantics_17: 1162 { 1163 /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */ 1164 #line 954 "rx-decode.opc" 1165 int mx AU = (op[1] >> 6) & 0x03; 1166 #line 954 "rx-decode.opc" 1167 int sd AU = op[1] & 0x03; 1168 #line 954 "rx-decode.opc" 1169 int rsrc AU = (op[3] >> 4) & 0x0f; 1170 #line 954 "rx-decode.opc" 1171 int rdst AU = op[3] & 0x0f; 1172 if (trace) 1173 { 1174 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 1175 "/** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */", 1176 op[0], op[1], op[2], op[3]); 1177 printf (" mx = 0x%x,", mx); 1178 printf (" sd = 0x%x,", sd); 1179 printf (" rsrc = 0x%x,", rsrc); 1180 printf (" rdst = 0x%x\n", rdst); 1181 } 1182 SYNTAX("itof %1%S1, %0"); 1183 #line 954 "rx-decode.opc" 1184 ID(itof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_; 1185 1186 /*----------------------------------------------------------------------*/ 1187 /* BIT OPS */ 1188 1189 } 1190 break; 1191 } 1192 break; 1193 case 0x15: 1194 GETBYTE (); 1195 switch (op[3] & 0x00) 1196 { 1197 case 0x00: 1198 op_semantics_18: 1199 { 1200 /** 0000 0110 mx10 00sd 0001 0101 rsrc rdst utof %1%S1, %0 */ 1201 #line 1140 "rx-decode.opc" 1202 int mx AU = (op[1] >> 6) & 0x03; 1203 #line 1140 "rx-decode.opc" 1204 int sd AU = op[1] & 0x03; 1205 #line 1140 "rx-decode.opc" 1206 int rsrc AU = (op[3] >> 4) & 0x0f; 1207 #line 1140 "rx-decode.opc" 1208 int rdst AU = op[3] & 0x0f; 1209 if (trace) 1210 { 1211 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 1212 "/** 0000 0110 mx10 00sd 0001 0101 rsrc rdst utof %1%S1, %0 */", 1213 op[0], op[1], op[2], op[3]); 1214 printf (" mx = 0x%x,", mx); 1215 printf (" sd = 0x%x,", sd); 1216 printf (" rsrc = 0x%x,", rsrc); 1217 printf (" rdst = 0x%x\n", rdst); 1218 } 1219 SYNTAX("utof %1%S1, %0"); 1220 #line 1140 "rx-decode.opc" 1221 ID(utof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_; 1222 1223 /*----------------------------------------------------------------------*/ 1224 /* RXv3 enhanced */ 1225 1226 } 1227 break; 1228 } 1229 break; 1230 default: UNSUPPORTED(); break; 1231 } 1232 break; 1233 case 0x21: 1234 GETBYTE (); 1235 switch (op[2] & 0xff) 1236 { 1237 case 0x00: 1238 GETBYTE (); 1239 switch (op[3] & 0x00) 1240 { 1241 case 0x00: 1242 goto op_semantics_7; 1243 break; 1244 } 1245 break; 1246 case 0x04: 1247 GETBYTE (); 1248 switch (op[3] & 0x00) 1249 { 1250 case 0x00: 1251 goto op_semantics_8; 1252 break; 1253 } 1254 break; 1255 case 0x05: 1256 GETBYTE (); 1257 switch (op[3] & 0x00) 1258 { 1259 case 0x00: 1260 goto op_semantics_9; 1261 break; 1262 } 1263 break; 1264 case 0x06: 1265 GETBYTE (); 1266 switch (op[3] & 0x00) 1267 { 1268 case 0x00: 1269 goto op_semantics_10; 1270 break; 1271 } 1272 break; 1273 case 0x07: 1274 GETBYTE (); 1275 switch (op[3] & 0x00) 1276 { 1277 case 0x00: 1278 goto op_semantics_11; 1279 break; 1280 } 1281 break; 1282 case 0x08: 1283 GETBYTE (); 1284 switch (op[3] & 0x00) 1285 { 1286 case 0x00: 1287 goto op_semantics_12; 1288 break; 1289 } 1290 break; 1291 case 0x09: 1292 GETBYTE (); 1293 switch (op[3] & 0x00) 1294 { 1295 case 0x00: 1296 goto op_semantics_13; 1297 break; 1298 } 1299 break; 1300 case 0x0c: 1301 GETBYTE (); 1302 switch (op[3] & 0x00) 1303 { 1304 case 0x00: 1305 goto op_semantics_14; 1306 break; 1307 } 1308 break; 1309 case 0x0d: 1310 GETBYTE (); 1311 switch (op[3] & 0x00) 1312 { 1313 case 0x00: 1314 goto op_semantics_15; 1315 break; 1316 } 1317 break; 1318 case 0x10: 1319 GETBYTE (); 1320 switch (op[3] & 0x00) 1321 { 1322 case 0x00: 1323 goto op_semantics_16; 1324 break; 1325 } 1326 break; 1327 case 0x11: 1328 GETBYTE (); 1329 switch (op[3] & 0x00) 1330 { 1331 case 0x00: 1332 goto op_semantics_17; 1333 break; 1334 } 1335 break; 1336 case 0x15: 1337 GETBYTE (); 1338 switch (op[3] & 0x00) 1339 { 1340 case 0x00: 1341 goto op_semantics_18; 1342 break; 1343 } 1344 break; 1345 default: UNSUPPORTED(); break; 1346 } 1347 break; 1348 case 0x22: 1349 GETBYTE (); 1350 switch (op[2] & 0xff) 1351 { 1352 case 0x00: 1353 GETBYTE (); 1354 switch (op[3] & 0x00) 1355 { 1356 case 0x00: 1357 goto op_semantics_7; 1358 break; 1359 } 1360 break; 1361 case 0x04: 1362 GETBYTE (); 1363 switch (op[3] & 0x00) 1364 { 1365 case 0x00: 1366 goto op_semantics_8; 1367 break; 1368 } 1369 break; 1370 case 0x05: 1371 GETBYTE (); 1372 switch (op[3] & 0x00) 1373 { 1374 case 0x00: 1375 goto op_semantics_9; 1376 break; 1377 } 1378 break; 1379 case 0x06: 1380 GETBYTE (); 1381 switch (op[3] & 0x00) 1382 { 1383 case 0x00: 1384 goto op_semantics_10; 1385 break; 1386 } 1387 break; 1388 case 0x07: 1389 GETBYTE (); 1390 switch (op[3] & 0x00) 1391 { 1392 case 0x00: 1393 goto op_semantics_11; 1394 break; 1395 } 1396 break; 1397 case 0x08: 1398 GETBYTE (); 1399 switch (op[3] & 0x00) 1400 { 1401 case 0x00: 1402 goto op_semantics_12; 1403 break; 1404 } 1405 break; 1406 case 0x09: 1407 GETBYTE (); 1408 switch (op[3] & 0x00) 1409 { 1410 case 0x00: 1411 goto op_semantics_13; 1412 break; 1413 } 1414 break; 1415 case 0x0c: 1416 GETBYTE (); 1417 switch (op[3] & 0x00) 1418 { 1419 case 0x00: 1420 goto op_semantics_14; 1421 break; 1422 } 1423 break; 1424 case 0x0d: 1425 GETBYTE (); 1426 switch (op[3] & 0x00) 1427 { 1428 case 0x00: 1429 goto op_semantics_15; 1430 break; 1431 } 1432 break; 1433 case 0x10: 1434 GETBYTE (); 1435 switch (op[3] & 0x00) 1436 { 1437 case 0x00: 1438 goto op_semantics_16; 1439 break; 1440 } 1441 break; 1442 case 0x11: 1443 GETBYTE (); 1444 switch (op[3] & 0x00) 1445 { 1446 case 0x00: 1447 goto op_semantics_17; 1448 break; 1449 } 1450 break; 1451 case 0x15: 1452 GETBYTE (); 1453 switch (op[3] & 0x00) 1454 { 1455 case 0x00: 1456 goto op_semantics_18; 1457 break; 1458 } 1459 break; 1460 default: UNSUPPORTED(); break; 1461 } 1462 break; 1463 case 0x23: 1464 GETBYTE (); 1465 switch (op[2] & 0xff) 1466 { 1467 case 0x00: 1468 GETBYTE (); 1469 switch (op[3] & 0x00) 1470 { 1471 case 0x00: 1472 goto op_semantics_7; 1473 break; 1474 } 1475 break; 1476 case 0x04: 1477 GETBYTE (); 1478 switch (op[3] & 0x00) 1479 { 1480 case 0x00: 1481 goto op_semantics_8; 1482 break; 1483 } 1484 break; 1485 case 0x05: 1486 GETBYTE (); 1487 switch (op[3] & 0x00) 1488 { 1489 case 0x00: 1490 goto op_semantics_9; 1491 break; 1492 } 1493 break; 1494 case 0x06: 1495 GETBYTE (); 1496 switch (op[3] & 0x00) 1497 { 1498 case 0x00: 1499 goto op_semantics_10; 1500 break; 1501 } 1502 break; 1503 case 0x07: 1504 GETBYTE (); 1505 switch (op[3] & 0x00) 1506 { 1507 case 0x00: 1508 goto op_semantics_11; 1509 break; 1510 } 1511 break; 1512 case 0x08: 1513 GETBYTE (); 1514 switch (op[3] & 0x00) 1515 { 1516 case 0x00: 1517 goto op_semantics_12; 1518 break; 1519 } 1520 break; 1521 case 0x09: 1522 GETBYTE (); 1523 switch (op[3] & 0x00) 1524 { 1525 case 0x00: 1526 goto op_semantics_13; 1527 break; 1528 } 1529 break; 1530 case 0x0c: 1531 GETBYTE (); 1532 switch (op[3] & 0x00) 1533 { 1534 case 0x00: 1535 goto op_semantics_14; 1536 break; 1537 } 1538 break; 1539 case 0x0d: 1540 GETBYTE (); 1541 switch (op[3] & 0x00) 1542 { 1543 case 0x00: 1544 goto op_semantics_15; 1545 break; 1546 } 1547 break; 1548 case 0x10: 1549 GETBYTE (); 1550 switch (op[3] & 0x00) 1551 { 1552 case 0x00: 1553 goto op_semantics_16; 1554 break; 1555 } 1556 break; 1557 case 0x11: 1558 GETBYTE (); 1559 switch (op[3] & 0x00) 1560 { 1561 case 0x00: 1562 goto op_semantics_17; 1563 break; 1564 } 1565 break; 1566 case 0x15: 1567 GETBYTE (); 1568 switch (op[3] & 0x00) 1569 { 1570 case 0x00: 1571 goto op_semantics_18; 1572 break; 1573 } 1574 break; 1575 default: UNSUPPORTED(); break; 1576 } 1577 break; 1578 case 0x40: 1579 GETBYTE (); 1580 switch (op[2] & 0x00) 1581 { 1582 case 0x00: 1583 goto op_semantics_1; 1584 break; 1585 } 1586 break; 1587 case 0x41: 1588 GETBYTE (); 1589 switch (op[2] & 0x00) 1590 { 1591 case 0x00: 1592 goto op_semantics_1; 1593 break; 1594 } 1595 break; 1596 case 0x42: 1597 GETBYTE (); 1598 switch (op[2] & 0x00) 1599 { 1600 case 0x00: 1601 goto op_semantics_1; 1602 break; 1603 } 1604 break; 1605 case 0x43: 1606 GETBYTE (); 1607 switch (op[2] & 0x00) 1608 { 1609 case 0x00: 1610 goto op_semantics_1; 1611 break; 1612 } 1613 break; 1614 case 0x44: 1615 GETBYTE (); 1616 switch (op[2] & 0x00) 1617 { 1618 case 0x00: 1619 goto op_semantics_2; 1620 break; 1621 } 1622 break; 1623 case 0x45: 1624 GETBYTE (); 1625 switch (op[2] & 0x00) 1626 { 1627 case 0x00: 1628 goto op_semantics_2; 1629 break; 1630 } 1631 break; 1632 case 0x46: 1633 GETBYTE (); 1634 switch (op[2] & 0x00) 1635 { 1636 case 0x00: 1637 goto op_semantics_2; 1638 break; 1639 } 1640 break; 1641 case 0x47: 1642 GETBYTE (); 1643 switch (op[2] & 0x00) 1644 { 1645 case 0x00: 1646 goto op_semantics_2; 1647 break; 1648 } 1649 break; 1650 case 0x48: 1651 GETBYTE (); 1652 switch (op[2] & 0x00) 1653 { 1654 case 0x00: 1655 goto op_semantics_3; 1656 break; 1657 } 1658 break; 1659 case 0x49: 1660 GETBYTE (); 1661 switch (op[2] & 0x00) 1662 { 1663 case 0x00: 1664 goto op_semantics_3; 1665 break; 1666 } 1667 break; 1668 case 0x4a: 1669 GETBYTE (); 1670 switch (op[2] & 0x00) 1671 { 1672 case 0x00: 1673 goto op_semantics_3; 1674 break; 1675 } 1676 break; 1677 case 0x4b: 1678 GETBYTE (); 1679 switch (op[2] & 0x00) 1680 { 1681 case 0x00: 1682 goto op_semantics_3; 1683 break; 1684 } 1685 break; 1686 case 0x4c: 1687 GETBYTE (); 1688 switch (op[2] & 0x00) 1689 { 1690 case 0x00: 1691 goto op_semantics_4; 1692 break; 1693 } 1694 break; 1695 case 0x4d: 1696 GETBYTE (); 1697 switch (op[2] & 0x00) 1698 { 1699 case 0x00: 1700 goto op_semantics_4; 1701 break; 1702 } 1703 break; 1704 case 0x4e: 1705 GETBYTE (); 1706 switch (op[2] & 0x00) 1707 { 1708 case 0x00: 1709 goto op_semantics_4; 1710 break; 1711 } 1712 break; 1713 case 0x4f: 1714 GETBYTE (); 1715 switch (op[2] & 0x00) 1716 { 1717 case 0x00: 1718 goto op_semantics_4; 1719 break; 1720 } 1721 break; 1722 case 0x50: 1723 GETBYTE (); 1724 switch (op[2] & 0x00) 1725 { 1726 case 0x00: 1727 goto op_semantics_5; 1728 break; 1729 } 1730 break; 1731 case 0x51: 1732 GETBYTE (); 1733 switch (op[2] & 0x00) 1734 { 1735 case 0x00: 1736 goto op_semantics_5; 1737 break; 1738 } 1739 break; 1740 case 0x52: 1741 GETBYTE (); 1742 switch (op[2] & 0x00) 1743 { 1744 case 0x00: 1745 goto op_semantics_5; 1746 break; 1747 } 1748 break; 1749 case 0x53: 1750 GETBYTE (); 1751 switch (op[2] & 0x00) 1752 { 1753 case 0x00: 1754 goto op_semantics_5; 1755 break; 1756 } 1757 break; 1758 case 0x54: 1759 GETBYTE (); 1760 switch (op[2] & 0x00) 1761 { 1762 case 0x00: 1763 goto op_semantics_6; 1764 break; 1765 } 1766 break; 1767 case 0x55: 1768 GETBYTE (); 1769 switch (op[2] & 0x00) 1770 { 1771 case 0x00: 1772 goto op_semantics_6; 1773 break; 1774 } 1775 break; 1776 case 0x56: 1777 GETBYTE (); 1778 switch (op[2] & 0x00) 1779 { 1780 case 0x00: 1781 goto op_semantics_6; 1782 break; 1783 } 1784 break; 1785 case 0x57: 1786 GETBYTE (); 1787 switch (op[2] & 0x00) 1788 { 1789 case 0x00: 1790 goto op_semantics_6; 1791 break; 1792 } 1793 break; 1794 case 0x60: 1795 GETBYTE (); 1796 switch (op[2] & 0xff) 1797 { 1798 case 0x00: 1799 GETBYTE (); 1800 switch (op[3] & 0x00) 1801 { 1802 case 0x00: 1803 goto op_semantics_7; 1804 break; 1805 } 1806 break; 1807 case 0x04: 1808 GETBYTE (); 1809 switch (op[3] & 0x00) 1810 { 1811 case 0x00: 1812 goto op_semantics_8; 1813 break; 1814 } 1815 break; 1816 case 0x05: 1817 GETBYTE (); 1818 switch (op[3] & 0x00) 1819 { 1820 case 0x00: 1821 goto op_semantics_9; 1822 break; 1823 } 1824 break; 1825 case 0x06: 1826 GETBYTE (); 1827 switch (op[3] & 0x00) 1828 { 1829 case 0x00: 1830 goto op_semantics_10; 1831 break; 1832 } 1833 break; 1834 case 0x07: 1835 GETBYTE (); 1836 switch (op[3] & 0x00) 1837 { 1838 case 0x00: 1839 goto op_semantics_11; 1840 break; 1841 } 1842 break; 1843 case 0x08: 1844 GETBYTE (); 1845 switch (op[3] & 0x00) 1846 { 1847 case 0x00: 1848 goto op_semantics_12; 1849 break; 1850 } 1851 break; 1852 case 0x09: 1853 GETBYTE (); 1854 switch (op[3] & 0x00) 1855 { 1856 case 0x00: 1857 goto op_semantics_13; 1858 break; 1859 } 1860 break; 1861 case 0x0c: 1862 GETBYTE (); 1863 switch (op[3] & 0x00) 1864 { 1865 case 0x00: 1866 goto op_semantics_14; 1867 break; 1868 } 1869 break; 1870 case 0x0d: 1871 GETBYTE (); 1872 switch (op[3] & 0x00) 1873 { 1874 case 0x00: 1875 goto op_semantics_15; 1876 break; 1877 } 1878 break; 1879 case 0x10: 1880 GETBYTE (); 1881 switch (op[3] & 0x00) 1882 { 1883 case 0x00: 1884 goto op_semantics_16; 1885 break; 1886 } 1887 break; 1888 case 0x11: 1889 GETBYTE (); 1890 switch (op[3] & 0x00) 1891 { 1892 case 0x00: 1893 goto op_semantics_17; 1894 break; 1895 } 1896 break; 1897 case 0x15: 1898 GETBYTE (); 1899 switch (op[3] & 0x00) 1900 { 1901 case 0x00: 1902 goto op_semantics_18; 1903 break; 1904 } 1905 break; 1906 default: UNSUPPORTED(); break; 1907 } 1908 break; 1909 case 0x61: 1910 GETBYTE (); 1911 switch (op[2] & 0xff) 1912 { 1913 case 0x00: 1914 GETBYTE (); 1915 switch (op[3] & 0x00) 1916 { 1917 case 0x00: 1918 goto op_semantics_7; 1919 break; 1920 } 1921 break; 1922 case 0x04: 1923 GETBYTE (); 1924 switch (op[3] & 0x00) 1925 { 1926 case 0x00: 1927 goto op_semantics_8; 1928 break; 1929 } 1930 break; 1931 case 0x05: 1932 GETBYTE (); 1933 switch (op[3] & 0x00) 1934 { 1935 case 0x00: 1936 goto op_semantics_9; 1937 break; 1938 } 1939 break; 1940 case 0x06: 1941 GETBYTE (); 1942 switch (op[3] & 0x00) 1943 { 1944 case 0x00: 1945 goto op_semantics_10; 1946 break; 1947 } 1948 break; 1949 case 0x07: 1950 GETBYTE (); 1951 switch (op[3] & 0x00) 1952 { 1953 case 0x00: 1954 goto op_semantics_11; 1955 break; 1956 } 1957 break; 1958 case 0x08: 1959 GETBYTE (); 1960 switch (op[3] & 0x00) 1961 { 1962 case 0x00: 1963 goto op_semantics_12; 1964 break; 1965 } 1966 break; 1967 case 0x09: 1968 GETBYTE (); 1969 switch (op[3] & 0x00) 1970 { 1971 case 0x00: 1972 goto op_semantics_13; 1973 break; 1974 } 1975 break; 1976 case 0x0c: 1977 GETBYTE (); 1978 switch (op[3] & 0x00) 1979 { 1980 case 0x00: 1981 goto op_semantics_14; 1982 break; 1983 } 1984 break; 1985 case 0x0d: 1986 GETBYTE (); 1987 switch (op[3] & 0x00) 1988 { 1989 case 0x00: 1990 goto op_semantics_15; 1991 break; 1992 } 1993 break; 1994 case 0x10: 1995 GETBYTE (); 1996 switch (op[3] & 0x00) 1997 { 1998 case 0x00: 1999 goto op_semantics_16; 2000 break; 2001 } 2002 break; 2003 case 0x11: 2004 GETBYTE (); 2005 switch (op[3] & 0x00) 2006 { 2007 case 0x00: 2008 goto op_semantics_17; 2009 break; 2010 } 2011 break; 2012 case 0x15: 2013 GETBYTE (); 2014 switch (op[3] & 0x00) 2015 { 2016 case 0x00: 2017 goto op_semantics_18; 2018 break; 2019 } 2020 break; 2021 default: UNSUPPORTED(); break; 2022 } 2023 break; 2024 case 0x62: 2025 GETBYTE (); 2026 switch (op[2] & 0xff) 2027 { 2028 case 0x00: 2029 GETBYTE (); 2030 switch (op[3] & 0x00) 2031 { 2032 case 0x00: 2033 goto op_semantics_7; 2034 break; 2035 } 2036 break; 2037 case 0x04: 2038 GETBYTE (); 2039 switch (op[3] & 0x00) 2040 { 2041 case 0x00: 2042 goto op_semantics_8; 2043 break; 2044 } 2045 break; 2046 case 0x05: 2047 GETBYTE (); 2048 switch (op[3] & 0x00) 2049 { 2050 case 0x00: 2051 goto op_semantics_9; 2052 break; 2053 } 2054 break; 2055 case 0x06: 2056 GETBYTE (); 2057 switch (op[3] & 0x00) 2058 { 2059 case 0x00: 2060 goto op_semantics_10; 2061 break; 2062 } 2063 break; 2064 case 0x07: 2065 GETBYTE (); 2066 switch (op[3] & 0x00) 2067 { 2068 case 0x00: 2069 goto op_semantics_11; 2070 break; 2071 } 2072 break; 2073 case 0x08: 2074 GETBYTE (); 2075 switch (op[3] & 0x00) 2076 { 2077 case 0x00: 2078 goto op_semantics_12; 2079 break; 2080 } 2081 break; 2082 case 0x09: 2083 GETBYTE (); 2084 switch (op[3] & 0x00) 2085 { 2086 case 0x00: 2087 goto op_semantics_13; 2088 break; 2089 } 2090 break; 2091 case 0x0c: 2092 GETBYTE (); 2093 switch (op[3] & 0x00) 2094 { 2095 case 0x00: 2096 goto op_semantics_14; 2097 break; 2098 } 2099 break; 2100 case 0x0d: 2101 GETBYTE (); 2102 switch (op[3] & 0x00) 2103 { 2104 case 0x00: 2105 goto op_semantics_15; 2106 break; 2107 } 2108 break; 2109 case 0x10: 2110 GETBYTE (); 2111 switch (op[3] & 0x00) 2112 { 2113 case 0x00: 2114 goto op_semantics_16; 2115 break; 2116 } 2117 break; 2118 case 0x11: 2119 GETBYTE (); 2120 switch (op[3] & 0x00) 2121 { 2122 case 0x00: 2123 goto op_semantics_17; 2124 break; 2125 } 2126 break; 2127 case 0x15: 2128 GETBYTE (); 2129 switch (op[3] & 0x00) 2130 { 2131 case 0x00: 2132 goto op_semantics_18; 2133 break; 2134 } 2135 break; 2136 default: UNSUPPORTED(); break; 2137 } 2138 break; 2139 case 0x63: 2140 GETBYTE (); 2141 switch (op[2] & 0xff) 2142 { 2143 case 0x00: 2144 GETBYTE (); 2145 switch (op[3] & 0x00) 2146 { 2147 case 0x00: 2148 goto op_semantics_7; 2149 break; 2150 } 2151 break; 2152 case 0x04: 2153 GETBYTE (); 2154 switch (op[3] & 0x00) 2155 { 2156 case 0x00: 2157 goto op_semantics_8; 2158 break; 2159 } 2160 break; 2161 case 0x05: 2162 GETBYTE (); 2163 switch (op[3] & 0x00) 2164 { 2165 case 0x00: 2166 goto op_semantics_9; 2167 break; 2168 } 2169 break; 2170 case 0x06: 2171 GETBYTE (); 2172 switch (op[3] & 0x00) 2173 { 2174 case 0x00: 2175 goto op_semantics_10; 2176 break; 2177 } 2178 break; 2179 case 0x07: 2180 GETBYTE (); 2181 switch (op[3] & 0x00) 2182 { 2183 case 0x00: 2184 goto op_semantics_11; 2185 break; 2186 } 2187 break; 2188 case 0x08: 2189 GETBYTE (); 2190 switch (op[3] & 0x00) 2191 { 2192 case 0x00: 2193 goto op_semantics_12; 2194 break; 2195 } 2196 break; 2197 case 0x09: 2198 GETBYTE (); 2199 switch (op[3] & 0x00) 2200 { 2201 case 0x00: 2202 goto op_semantics_13; 2203 break; 2204 } 2205 break; 2206 case 0x0c: 2207 GETBYTE (); 2208 switch (op[3] & 0x00) 2209 { 2210 case 0x00: 2211 goto op_semantics_14; 2212 break; 2213 } 2214 break; 2215 case 0x0d: 2216 GETBYTE (); 2217 switch (op[3] & 0x00) 2218 { 2219 case 0x00: 2220 goto op_semantics_15; 2221 break; 2222 } 2223 break; 2224 case 0x10: 2225 GETBYTE (); 2226 switch (op[3] & 0x00) 2227 { 2228 case 0x00: 2229 goto op_semantics_16; 2230 break; 2231 } 2232 break; 2233 case 0x11: 2234 GETBYTE (); 2235 switch (op[3] & 0x00) 2236 { 2237 case 0x00: 2238 goto op_semantics_17; 2239 break; 2240 } 2241 break; 2242 case 0x15: 2243 GETBYTE (); 2244 switch (op[3] & 0x00) 2245 { 2246 case 0x00: 2247 goto op_semantics_18; 2248 break; 2249 } 2250 break; 2251 default: UNSUPPORTED(); break; 2252 } 2253 break; 2254 case 0x80: 2255 GETBYTE (); 2256 switch (op[2] & 0x00) 2257 { 2258 case 0x00: 2259 goto op_semantics_1; 2260 break; 2261 } 2262 break; 2263 case 0x81: 2264 GETBYTE (); 2265 switch (op[2] & 0x00) 2266 { 2267 case 0x00: 2268 goto op_semantics_1; 2269 break; 2270 } 2271 break; 2272 case 0x82: 2273 GETBYTE (); 2274 switch (op[2] & 0x00) 2275 { 2276 case 0x00: 2277 goto op_semantics_1; 2278 break; 2279 } 2280 break; 2281 case 0x83: 2282 GETBYTE (); 2283 switch (op[2] & 0x00) 2284 { 2285 case 0x00: 2286 goto op_semantics_1; 2287 break; 2288 } 2289 break; 2290 case 0x84: 2291 GETBYTE (); 2292 switch (op[2] & 0x00) 2293 { 2294 case 0x00: 2295 goto op_semantics_2; 2296 break; 2297 } 2298 break; 2299 case 0x85: 2300 GETBYTE (); 2301 switch (op[2] & 0x00) 2302 { 2303 case 0x00: 2304 goto op_semantics_2; 2305 break; 2306 } 2307 break; 2308 case 0x86: 2309 GETBYTE (); 2310 switch (op[2] & 0x00) 2311 { 2312 case 0x00: 2313 goto op_semantics_2; 2314 break; 2315 } 2316 break; 2317 case 0x87: 2318 GETBYTE (); 2319 switch (op[2] & 0x00) 2320 { 2321 case 0x00: 2322 goto op_semantics_2; 2323 break; 2324 } 2325 break; 2326 case 0x88: 2327 GETBYTE (); 2328 switch (op[2] & 0x00) 2329 { 2330 case 0x00: 2331 goto op_semantics_3; 2332 break; 2333 } 2334 break; 2335 case 0x89: 2336 GETBYTE (); 2337 switch (op[2] & 0x00) 2338 { 2339 case 0x00: 2340 goto op_semantics_3; 2341 break; 2342 } 2343 break; 2344 case 0x8a: 2345 GETBYTE (); 2346 switch (op[2] & 0x00) 2347 { 2348 case 0x00: 2349 goto op_semantics_3; 2350 break; 2351 } 2352 break; 2353 case 0x8b: 2354 GETBYTE (); 2355 switch (op[2] & 0x00) 2356 { 2357 case 0x00: 2358 goto op_semantics_3; 2359 break; 2360 } 2361 break; 2362 case 0x8c: 2363 GETBYTE (); 2364 switch (op[2] & 0x00) 2365 { 2366 case 0x00: 2367 goto op_semantics_4; 2368 break; 2369 } 2370 break; 2371 case 0x8d: 2372 GETBYTE (); 2373 switch (op[2] & 0x00) 2374 { 2375 case 0x00: 2376 goto op_semantics_4; 2377 break; 2378 } 2379 break; 2380 case 0x8e: 2381 GETBYTE (); 2382 switch (op[2] & 0x00) 2383 { 2384 case 0x00: 2385 goto op_semantics_4; 2386 break; 2387 } 2388 break; 2389 case 0x8f: 2390 GETBYTE (); 2391 switch (op[2] & 0x00) 2392 { 2393 case 0x00: 2394 goto op_semantics_4; 2395 break; 2396 } 2397 break; 2398 case 0x90: 2399 GETBYTE (); 2400 switch (op[2] & 0x00) 2401 { 2402 case 0x00: 2403 goto op_semantics_5; 2404 break; 2405 } 2406 break; 2407 case 0x91: 2408 GETBYTE (); 2409 switch (op[2] & 0x00) 2410 { 2411 case 0x00: 2412 goto op_semantics_5; 2413 break; 2414 } 2415 break; 2416 case 0x92: 2417 GETBYTE (); 2418 switch (op[2] & 0x00) 2419 { 2420 case 0x00: 2421 goto op_semantics_5; 2422 break; 2423 } 2424 break; 2425 case 0x93: 2426 GETBYTE (); 2427 switch (op[2] & 0x00) 2428 { 2429 case 0x00: 2430 goto op_semantics_5; 2431 break; 2432 } 2433 break; 2434 case 0x94: 2435 GETBYTE (); 2436 switch (op[2] & 0x00) 2437 { 2438 case 0x00: 2439 goto op_semantics_6; 2440 break; 2441 } 2442 break; 2443 case 0x95: 2444 GETBYTE (); 2445 switch (op[2] & 0x00) 2446 { 2447 case 0x00: 2448 goto op_semantics_6; 2449 break; 2450 } 2451 break; 2452 case 0x96: 2453 GETBYTE (); 2454 switch (op[2] & 0x00) 2455 { 2456 case 0x00: 2457 goto op_semantics_6; 2458 break; 2459 } 2460 break; 2461 case 0x97: 2462 GETBYTE (); 2463 switch (op[2] & 0x00) 2464 { 2465 case 0x00: 2466 goto op_semantics_6; 2467 break; 2468 } 2469 break; 2470 case 0xa0: 2471 GETBYTE (); 2472 switch (op[2] & 0xff) 2473 { 2474 case 0x00: 2475 GETBYTE (); 2476 switch (op[3] & 0x00) 2477 { 2478 case 0x00: 2479 goto op_semantics_7; 2480 break; 2481 } 2482 break; 2483 case 0x02: 2484 GETBYTE (); 2485 switch (op[3] & 0x00) 2486 { 2487 case 0x00: 2488 op_semantics_19: 2489 { 2490 /** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */ 2491 #line 519 "rx-decode.opc" 2492 int ss AU = op[1] & 0x03; 2493 #line 519 "rx-decode.opc" 2494 int rsrc AU = (op[3] >> 4) & 0x0f; 2495 #line 519 "rx-decode.opc" 2496 int rdst AU = op[3] & 0x0f; 2497 if (trace) 2498 { 2499 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 2500 "/** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */", 2501 op[0], op[1], op[2], op[3]); 2502 printf (" ss = 0x%x,", ss); 2503 printf (" rsrc = 0x%x,", rsrc); 2504 printf (" rdst = 0x%x\n", rdst); 2505 } 2506 SYNTAX("adc %1%S1, %0"); 2507 #line 519 "rx-decode.opc" 2508 ID(adc); SPm(ss, rsrc, 2); DR(rdst); F_OSZC; 2509 2510 /*----------------------------------------------------------------------*/ 2511 /* ADD */ 2512 2513 } 2514 break; 2515 } 2516 break; 2517 case 0x04: 2518 GETBYTE (); 2519 switch (op[3] & 0x00) 2520 { 2521 case 0x00: 2522 goto op_semantics_8; 2523 break; 2524 } 2525 break; 2526 case 0x05: 2527 GETBYTE (); 2528 switch (op[3] & 0x00) 2529 { 2530 case 0x00: 2531 goto op_semantics_9; 2532 break; 2533 } 2534 break; 2535 case 0x06: 2536 GETBYTE (); 2537 switch (op[3] & 0x00) 2538 { 2539 case 0x00: 2540 goto op_semantics_10; 2541 break; 2542 } 2543 break; 2544 case 0x07: 2545 GETBYTE (); 2546 switch (op[3] & 0x00) 2547 { 2548 case 0x00: 2549 goto op_semantics_11; 2550 break; 2551 } 2552 break; 2553 case 0x08: 2554 GETBYTE (); 2555 switch (op[3] & 0x00) 2556 { 2557 case 0x00: 2558 goto op_semantics_12; 2559 break; 2560 } 2561 break; 2562 case 0x09: 2563 GETBYTE (); 2564 switch (op[3] & 0x00) 2565 { 2566 case 0x00: 2567 goto op_semantics_13; 2568 break; 2569 } 2570 break; 2571 case 0x0c: 2572 GETBYTE (); 2573 switch (op[3] & 0x00) 2574 { 2575 case 0x00: 2576 goto op_semantics_14; 2577 break; 2578 } 2579 break; 2580 case 0x0d: 2581 GETBYTE (); 2582 switch (op[3] & 0x00) 2583 { 2584 case 0x00: 2585 goto op_semantics_15; 2586 break; 2587 } 2588 break; 2589 case 0x10: 2590 GETBYTE (); 2591 switch (op[3] & 0x00) 2592 { 2593 case 0x00: 2594 goto op_semantics_16; 2595 break; 2596 } 2597 break; 2598 case 0x11: 2599 GETBYTE (); 2600 switch (op[3] & 0x00) 2601 { 2602 case 0x00: 2603 goto op_semantics_17; 2604 break; 2605 } 2606 break; 2607 case 0x15: 2608 GETBYTE (); 2609 switch (op[3] & 0x00) 2610 { 2611 case 0x00: 2612 goto op_semantics_18; 2613 break; 2614 } 2615 break; 2616 default: UNSUPPORTED(); break; 2617 } 2618 break; 2619 case 0xa1: 2620 GETBYTE (); 2621 switch (op[2] & 0xff) 2622 { 2623 case 0x00: 2624 GETBYTE (); 2625 switch (op[3] & 0x00) 2626 { 2627 case 0x00: 2628 goto op_semantics_7; 2629 break; 2630 } 2631 break; 2632 case 0x02: 2633 GETBYTE (); 2634 switch (op[3] & 0x00) 2635 { 2636 case 0x00: 2637 goto op_semantics_19; 2638 break; 2639 } 2640 break; 2641 case 0x04: 2642 GETBYTE (); 2643 switch (op[3] & 0x00) 2644 { 2645 case 0x00: 2646 goto op_semantics_8; 2647 break; 2648 } 2649 break; 2650 case 0x05: 2651 GETBYTE (); 2652 switch (op[3] & 0x00) 2653 { 2654 case 0x00: 2655 goto op_semantics_9; 2656 break; 2657 } 2658 break; 2659 case 0x06: 2660 GETBYTE (); 2661 switch (op[3] & 0x00) 2662 { 2663 case 0x00: 2664 goto op_semantics_10; 2665 break; 2666 } 2667 break; 2668 case 0x07: 2669 GETBYTE (); 2670 switch (op[3] & 0x00) 2671 { 2672 case 0x00: 2673 goto op_semantics_11; 2674 break; 2675 } 2676 break; 2677 case 0x08: 2678 GETBYTE (); 2679 switch (op[3] & 0x00) 2680 { 2681 case 0x00: 2682 goto op_semantics_12; 2683 break; 2684 } 2685 break; 2686 case 0x09: 2687 GETBYTE (); 2688 switch (op[3] & 0x00) 2689 { 2690 case 0x00: 2691 goto op_semantics_13; 2692 break; 2693 } 2694 break; 2695 case 0x0c: 2696 GETBYTE (); 2697 switch (op[3] & 0x00) 2698 { 2699 case 0x00: 2700 goto op_semantics_14; 2701 break; 2702 } 2703 break; 2704 case 0x0d: 2705 GETBYTE (); 2706 switch (op[3] & 0x00) 2707 { 2708 case 0x00: 2709 goto op_semantics_15; 2710 break; 2711 } 2712 break; 2713 case 0x10: 2714 GETBYTE (); 2715 switch (op[3] & 0x00) 2716 { 2717 case 0x00: 2718 goto op_semantics_16; 2719 break; 2720 } 2721 break; 2722 case 0x11: 2723 GETBYTE (); 2724 switch (op[3] & 0x00) 2725 { 2726 case 0x00: 2727 goto op_semantics_17; 2728 break; 2729 } 2730 break; 2731 case 0x15: 2732 GETBYTE (); 2733 switch (op[3] & 0x00) 2734 { 2735 case 0x00: 2736 goto op_semantics_18; 2737 break; 2738 } 2739 break; 2740 default: UNSUPPORTED(); break; 2741 } 2742 break; 2743 case 0xa2: 2744 GETBYTE (); 2745 switch (op[2] & 0xff) 2746 { 2747 case 0x00: 2748 GETBYTE (); 2749 switch (op[3] & 0x00) 2750 { 2751 case 0x00: 2752 goto op_semantics_7; 2753 break; 2754 } 2755 break; 2756 case 0x02: 2757 GETBYTE (); 2758 switch (op[3] & 0x00) 2759 { 2760 case 0x00: 2761 goto op_semantics_19; 2762 break; 2763 } 2764 break; 2765 case 0x04: 2766 GETBYTE (); 2767 switch (op[3] & 0x00) 2768 { 2769 case 0x00: 2770 goto op_semantics_8; 2771 break; 2772 } 2773 break; 2774 case 0x05: 2775 GETBYTE (); 2776 switch (op[3] & 0x00) 2777 { 2778 case 0x00: 2779 goto op_semantics_9; 2780 break; 2781 } 2782 break; 2783 case 0x06: 2784 GETBYTE (); 2785 switch (op[3] & 0x00) 2786 { 2787 case 0x00: 2788 goto op_semantics_10; 2789 break; 2790 } 2791 break; 2792 case 0x07: 2793 GETBYTE (); 2794 switch (op[3] & 0x00) 2795 { 2796 case 0x00: 2797 goto op_semantics_11; 2798 break; 2799 } 2800 break; 2801 case 0x08: 2802 GETBYTE (); 2803 switch (op[3] & 0x00) 2804 { 2805 case 0x00: 2806 goto op_semantics_12; 2807 break; 2808 } 2809 break; 2810 case 0x09: 2811 GETBYTE (); 2812 switch (op[3] & 0x00) 2813 { 2814 case 0x00: 2815 goto op_semantics_13; 2816 break; 2817 } 2818 break; 2819 case 0x0c: 2820 GETBYTE (); 2821 switch (op[3] & 0x00) 2822 { 2823 case 0x00: 2824 goto op_semantics_14; 2825 break; 2826 } 2827 break; 2828 case 0x0d: 2829 GETBYTE (); 2830 switch (op[3] & 0x00) 2831 { 2832 case 0x00: 2833 goto op_semantics_15; 2834 break; 2835 } 2836 break; 2837 case 0x10: 2838 GETBYTE (); 2839 switch (op[3] & 0x00) 2840 { 2841 case 0x00: 2842 goto op_semantics_16; 2843 break; 2844 } 2845 break; 2846 case 0x11: 2847 GETBYTE (); 2848 switch (op[3] & 0x00) 2849 { 2850 case 0x00: 2851 goto op_semantics_17; 2852 break; 2853 } 2854 break; 2855 case 0x15: 2856 GETBYTE (); 2857 switch (op[3] & 0x00) 2858 { 2859 case 0x00: 2860 goto op_semantics_18; 2861 break; 2862 } 2863 break; 2864 default: UNSUPPORTED(); break; 2865 } 2866 break; 2867 case 0xa3: 2868 GETBYTE (); 2869 switch (op[2] & 0xff) 2870 { 2871 case 0x00: 2872 GETBYTE (); 2873 switch (op[3] & 0x00) 2874 { 2875 case 0x00: 2876 goto op_semantics_7; 2877 break; 2878 } 2879 break; 2880 case 0x02: 2881 GETBYTE (); 2882 switch (op[3] & 0x00) 2883 { 2884 case 0x00: 2885 goto op_semantics_19; 2886 break; 2887 } 2888 break; 2889 case 0x04: 2890 GETBYTE (); 2891 switch (op[3] & 0x00) 2892 { 2893 case 0x00: 2894 goto op_semantics_8; 2895 break; 2896 } 2897 break; 2898 case 0x05: 2899 GETBYTE (); 2900 switch (op[3] & 0x00) 2901 { 2902 case 0x00: 2903 goto op_semantics_9; 2904 break; 2905 } 2906 break; 2907 case 0x06: 2908 GETBYTE (); 2909 switch (op[3] & 0x00) 2910 { 2911 case 0x00: 2912 goto op_semantics_10; 2913 break; 2914 } 2915 break; 2916 case 0x07: 2917 GETBYTE (); 2918 switch (op[3] & 0x00) 2919 { 2920 case 0x00: 2921 goto op_semantics_11; 2922 break; 2923 } 2924 break; 2925 case 0x08: 2926 GETBYTE (); 2927 switch (op[3] & 0x00) 2928 { 2929 case 0x00: 2930 goto op_semantics_12; 2931 break; 2932 } 2933 break; 2934 case 0x09: 2935 GETBYTE (); 2936 switch (op[3] & 0x00) 2937 { 2938 case 0x00: 2939 goto op_semantics_13; 2940 break; 2941 } 2942 break; 2943 case 0x0c: 2944 GETBYTE (); 2945 switch (op[3] & 0x00) 2946 { 2947 case 0x00: 2948 goto op_semantics_14; 2949 break; 2950 } 2951 break; 2952 case 0x0d: 2953 GETBYTE (); 2954 switch (op[3] & 0x00) 2955 { 2956 case 0x00: 2957 goto op_semantics_15; 2958 break; 2959 } 2960 break; 2961 case 0x10: 2962 GETBYTE (); 2963 switch (op[3] & 0x00) 2964 { 2965 case 0x00: 2966 goto op_semantics_16; 2967 break; 2968 } 2969 break; 2970 case 0x11: 2971 GETBYTE (); 2972 switch (op[3] & 0x00) 2973 { 2974 case 0x00: 2975 goto op_semantics_17; 2976 break; 2977 } 2978 break; 2979 case 0x15: 2980 GETBYTE (); 2981 switch (op[3] & 0x00) 2982 { 2983 case 0x00: 2984 goto op_semantics_18; 2985 break; 2986 } 2987 break; 2988 default: UNSUPPORTED(); break; 2989 } 2990 break; 2991 case 0xc0: 2992 GETBYTE (); 2993 switch (op[2] & 0x00) 2994 { 2995 case 0x00: 2996 goto op_semantics_1; 2997 break; 2998 } 2999 break; 3000 case 0xc1: 3001 GETBYTE (); 3002 switch (op[2] & 0x00) 3003 { 3004 case 0x00: 3005 goto op_semantics_1; 3006 break; 3007 } 3008 break; 3009 case 0xc2: 3010 GETBYTE (); 3011 switch (op[2] & 0x00) 3012 { 3013 case 0x00: 3014 goto op_semantics_1; 3015 break; 3016 } 3017 break; 3018 case 0xc3: 3019 GETBYTE (); 3020 switch (op[2] & 0x00) 3021 { 3022 case 0x00: 3023 goto op_semantics_1; 3024 break; 3025 } 3026 break; 3027 case 0xc4: 3028 GETBYTE (); 3029 switch (op[2] & 0x00) 3030 { 3031 case 0x00: 3032 goto op_semantics_2; 3033 break; 3034 } 3035 break; 3036 case 0xc5: 3037 GETBYTE (); 3038 switch (op[2] & 0x00) 3039 { 3040 case 0x00: 3041 goto op_semantics_2; 3042 break; 3043 } 3044 break; 3045 case 0xc6: 3046 GETBYTE (); 3047 switch (op[2] & 0x00) 3048 { 3049 case 0x00: 3050 goto op_semantics_2; 3051 break; 3052 } 3053 break; 3054 case 0xc7: 3055 GETBYTE (); 3056 switch (op[2] & 0x00) 3057 { 3058 case 0x00: 3059 goto op_semantics_2; 3060 break; 3061 } 3062 break; 3063 case 0xc8: 3064 GETBYTE (); 3065 switch (op[2] & 0x00) 3066 { 3067 case 0x00: 3068 goto op_semantics_3; 3069 break; 3070 } 3071 break; 3072 case 0xc9: 3073 GETBYTE (); 3074 switch (op[2] & 0x00) 3075 { 3076 case 0x00: 3077 goto op_semantics_3; 3078 break; 3079 } 3080 break; 3081 case 0xca: 3082 GETBYTE (); 3083 switch (op[2] & 0x00) 3084 { 3085 case 0x00: 3086 goto op_semantics_3; 3087 break; 3088 } 3089 break; 3090 case 0xcb: 3091 GETBYTE (); 3092 switch (op[2] & 0x00) 3093 { 3094 case 0x00: 3095 goto op_semantics_3; 3096 break; 3097 } 3098 break; 3099 case 0xcc: 3100 GETBYTE (); 3101 switch (op[2] & 0x00) 3102 { 3103 case 0x00: 3104 goto op_semantics_4; 3105 break; 3106 } 3107 break; 3108 case 0xcd: 3109 GETBYTE (); 3110 switch (op[2] & 0x00) 3111 { 3112 case 0x00: 3113 goto op_semantics_4; 3114 break; 3115 } 3116 break; 3117 case 0xce: 3118 GETBYTE (); 3119 switch (op[2] & 0x00) 3120 { 3121 case 0x00: 3122 goto op_semantics_4; 3123 break; 3124 } 3125 break; 3126 case 0xcf: 3127 GETBYTE (); 3128 switch (op[2] & 0x00) 3129 { 3130 case 0x00: 3131 goto op_semantics_4; 3132 break; 3133 } 3134 break; 3135 case 0xd0: 3136 GETBYTE (); 3137 switch (op[2] & 0x00) 3138 { 3139 case 0x00: 3140 goto op_semantics_5; 3141 break; 3142 } 3143 break; 3144 case 0xd1: 3145 GETBYTE (); 3146 switch (op[2] & 0x00) 3147 { 3148 case 0x00: 3149 goto op_semantics_5; 3150 break; 3151 } 3152 break; 3153 case 0xd2: 3154 GETBYTE (); 3155 switch (op[2] & 0x00) 3156 { 3157 case 0x00: 3158 goto op_semantics_5; 3159 break; 3160 } 3161 break; 3162 case 0xd3: 3163 GETBYTE (); 3164 switch (op[2] & 0x00) 3165 { 3166 case 0x00: 3167 goto op_semantics_5; 3168 break; 3169 } 3170 break; 3171 case 0xd4: 3172 GETBYTE (); 3173 switch (op[2] & 0x00) 3174 { 3175 case 0x00: 3176 goto op_semantics_6; 3177 break; 3178 } 3179 break; 3180 case 0xd5: 3181 GETBYTE (); 3182 switch (op[2] & 0x00) 3183 { 3184 case 0x00: 3185 goto op_semantics_6; 3186 break; 3187 } 3188 break; 3189 case 0xd6: 3190 GETBYTE (); 3191 switch (op[2] & 0x00) 3192 { 3193 case 0x00: 3194 goto op_semantics_6; 3195 break; 3196 } 3197 break; 3198 case 0xd7: 3199 GETBYTE (); 3200 switch (op[2] & 0x00) 3201 { 3202 case 0x00: 3203 goto op_semantics_6; 3204 break; 3205 } 3206 break; 3207 case 0xe0: 3208 GETBYTE (); 3209 switch (op[2] & 0xff) 3210 { 3211 case 0x00: 3212 GETBYTE (); 3213 switch (op[3] & 0x00) 3214 { 3215 case 0x00: 3216 goto op_semantics_7; 3217 break; 3218 } 3219 break; 3220 case 0x04: 3221 GETBYTE (); 3222 switch (op[3] & 0x00) 3223 { 3224 case 0x00: 3225 goto op_semantics_8; 3226 break; 3227 } 3228 break; 3229 case 0x05: 3230 GETBYTE (); 3231 switch (op[3] & 0x00) 3232 { 3233 case 0x00: 3234 goto op_semantics_9; 3235 break; 3236 } 3237 break; 3238 case 0x06: 3239 GETBYTE (); 3240 switch (op[3] & 0x00) 3241 { 3242 case 0x00: 3243 goto op_semantics_10; 3244 break; 3245 } 3246 break; 3247 case 0x07: 3248 GETBYTE (); 3249 switch (op[3] & 0x00) 3250 { 3251 case 0x00: 3252 goto op_semantics_11; 3253 break; 3254 } 3255 break; 3256 case 0x08: 3257 GETBYTE (); 3258 switch (op[3] & 0x00) 3259 { 3260 case 0x00: 3261 goto op_semantics_12; 3262 break; 3263 } 3264 break; 3265 case 0x09: 3266 GETBYTE (); 3267 switch (op[3] & 0x00) 3268 { 3269 case 0x00: 3270 goto op_semantics_13; 3271 break; 3272 } 3273 break; 3274 case 0x0c: 3275 GETBYTE (); 3276 switch (op[3] & 0x00) 3277 { 3278 case 0x00: 3279 goto op_semantics_14; 3280 break; 3281 } 3282 break; 3283 case 0x0d: 3284 GETBYTE (); 3285 switch (op[3] & 0x00) 3286 { 3287 case 0x00: 3288 goto op_semantics_15; 3289 break; 3290 } 3291 break; 3292 case 0x10: 3293 GETBYTE (); 3294 switch (op[3] & 0x00) 3295 { 3296 case 0x00: 3297 goto op_semantics_16; 3298 break; 3299 } 3300 break; 3301 case 0x11: 3302 GETBYTE (); 3303 switch (op[3] & 0x00) 3304 { 3305 case 0x00: 3306 goto op_semantics_17; 3307 break; 3308 } 3309 break; 3310 case 0x15: 3311 GETBYTE (); 3312 switch (op[3] & 0x00) 3313 { 3314 case 0x00: 3315 goto op_semantics_18; 3316 break; 3317 } 3318 break; 3319 default: UNSUPPORTED(); break; 3320 } 3321 break; 3322 case 0xe1: 3323 GETBYTE (); 3324 switch (op[2] & 0xff) 3325 { 3326 case 0x00: 3327 GETBYTE (); 3328 switch (op[3] & 0x00) 3329 { 3330 case 0x00: 3331 goto op_semantics_7; 3332 break; 3333 } 3334 break; 3335 case 0x04: 3336 GETBYTE (); 3337 switch (op[3] & 0x00) 3338 { 3339 case 0x00: 3340 goto op_semantics_8; 3341 break; 3342 } 3343 break; 3344 case 0x05: 3345 GETBYTE (); 3346 switch (op[3] & 0x00) 3347 { 3348 case 0x00: 3349 goto op_semantics_9; 3350 break; 3351 } 3352 break; 3353 case 0x06: 3354 GETBYTE (); 3355 switch (op[3] & 0x00) 3356 { 3357 case 0x00: 3358 goto op_semantics_10; 3359 break; 3360 } 3361 break; 3362 case 0x07: 3363 GETBYTE (); 3364 switch (op[3] & 0x00) 3365 { 3366 case 0x00: 3367 goto op_semantics_11; 3368 break; 3369 } 3370 break; 3371 case 0x08: 3372 GETBYTE (); 3373 switch (op[3] & 0x00) 3374 { 3375 case 0x00: 3376 goto op_semantics_12; 3377 break; 3378 } 3379 break; 3380 case 0x09: 3381 GETBYTE (); 3382 switch (op[3] & 0x00) 3383 { 3384 case 0x00: 3385 goto op_semantics_13; 3386 break; 3387 } 3388 break; 3389 case 0x0c: 3390 GETBYTE (); 3391 switch (op[3] & 0x00) 3392 { 3393 case 0x00: 3394 goto op_semantics_14; 3395 break; 3396 } 3397 break; 3398 case 0x0d: 3399 GETBYTE (); 3400 switch (op[3] & 0x00) 3401 { 3402 case 0x00: 3403 goto op_semantics_15; 3404 break; 3405 } 3406 break; 3407 case 0x10: 3408 GETBYTE (); 3409 switch (op[3] & 0x00) 3410 { 3411 case 0x00: 3412 goto op_semantics_16; 3413 break; 3414 } 3415 break; 3416 case 0x11: 3417 GETBYTE (); 3418 switch (op[3] & 0x00) 3419 { 3420 case 0x00: 3421 goto op_semantics_17; 3422 break; 3423 } 3424 break; 3425 case 0x15: 3426 GETBYTE (); 3427 switch (op[3] & 0x00) 3428 { 3429 case 0x00: 3430 goto op_semantics_18; 3431 break; 3432 } 3433 break; 3434 default: UNSUPPORTED(); break; 3435 } 3436 break; 3437 case 0xe2: 3438 GETBYTE (); 3439 switch (op[2] & 0xff) 3440 { 3441 case 0x00: 3442 GETBYTE (); 3443 switch (op[3] & 0x00) 3444 { 3445 case 0x00: 3446 goto op_semantics_7; 3447 break; 3448 } 3449 break; 3450 case 0x04: 3451 GETBYTE (); 3452 switch (op[3] & 0x00) 3453 { 3454 case 0x00: 3455 goto op_semantics_8; 3456 break; 3457 } 3458 break; 3459 case 0x05: 3460 GETBYTE (); 3461 switch (op[3] & 0x00) 3462 { 3463 case 0x00: 3464 goto op_semantics_9; 3465 break; 3466 } 3467 break; 3468 case 0x06: 3469 GETBYTE (); 3470 switch (op[3] & 0x00) 3471 { 3472 case 0x00: 3473 goto op_semantics_10; 3474 break; 3475 } 3476 break; 3477 case 0x07: 3478 GETBYTE (); 3479 switch (op[3] & 0x00) 3480 { 3481 case 0x00: 3482 goto op_semantics_11; 3483 break; 3484 } 3485 break; 3486 case 0x08: 3487 GETBYTE (); 3488 switch (op[3] & 0x00) 3489 { 3490 case 0x00: 3491 goto op_semantics_12; 3492 break; 3493 } 3494 break; 3495 case 0x09: 3496 GETBYTE (); 3497 switch (op[3] & 0x00) 3498 { 3499 case 0x00: 3500 goto op_semantics_13; 3501 break; 3502 } 3503 break; 3504 case 0x0c: 3505 GETBYTE (); 3506 switch (op[3] & 0x00) 3507 { 3508 case 0x00: 3509 goto op_semantics_14; 3510 break; 3511 } 3512 break; 3513 case 0x0d: 3514 GETBYTE (); 3515 switch (op[3] & 0x00) 3516 { 3517 case 0x00: 3518 goto op_semantics_15; 3519 break; 3520 } 3521 break; 3522 case 0x10: 3523 GETBYTE (); 3524 switch (op[3] & 0x00) 3525 { 3526 case 0x00: 3527 goto op_semantics_16; 3528 break; 3529 } 3530 break; 3531 case 0x11: 3532 GETBYTE (); 3533 switch (op[3] & 0x00) 3534 { 3535 case 0x00: 3536 goto op_semantics_17; 3537 break; 3538 } 3539 break; 3540 case 0x15: 3541 GETBYTE (); 3542 switch (op[3] & 0x00) 3543 { 3544 case 0x00: 3545 goto op_semantics_18; 3546 break; 3547 } 3548 break; 3549 default: UNSUPPORTED(); break; 3550 } 3551 break; 3552 case 0xe3: 3553 GETBYTE (); 3554 switch (op[2] & 0xff) 3555 { 3556 case 0x00: 3557 GETBYTE (); 3558 switch (op[3] & 0x00) 3559 { 3560 case 0x00: 3561 goto op_semantics_7; 3562 break; 3563 } 3564 break; 3565 case 0x04: 3566 GETBYTE (); 3567 switch (op[3] & 0x00) 3568 { 3569 case 0x00: 3570 goto op_semantics_8; 3571 break; 3572 } 3573 break; 3574 case 0x05: 3575 GETBYTE (); 3576 switch (op[3] & 0x00) 3577 { 3578 case 0x00: 3579 goto op_semantics_9; 3580 break; 3581 } 3582 break; 3583 case 0x06: 3584 GETBYTE (); 3585 switch (op[3] & 0x00) 3586 { 3587 case 0x00: 3588 goto op_semantics_10; 3589 break; 3590 } 3591 break; 3592 case 0x07: 3593 GETBYTE (); 3594 switch (op[3] & 0x00) 3595 { 3596 case 0x00: 3597 goto op_semantics_11; 3598 break; 3599 } 3600 break; 3601 case 0x08: 3602 GETBYTE (); 3603 switch (op[3] & 0x00) 3604 { 3605 case 0x00: 3606 goto op_semantics_12; 3607 break; 3608 } 3609 break; 3610 case 0x09: 3611 GETBYTE (); 3612 switch (op[3] & 0x00) 3613 { 3614 case 0x00: 3615 goto op_semantics_13; 3616 break; 3617 } 3618 break; 3619 case 0x0c: 3620 GETBYTE (); 3621 switch (op[3] & 0x00) 3622 { 3623 case 0x00: 3624 goto op_semantics_14; 3625 break; 3626 } 3627 break; 3628 case 0x0d: 3629 GETBYTE (); 3630 switch (op[3] & 0x00) 3631 { 3632 case 0x00: 3633 goto op_semantics_15; 3634 break; 3635 } 3636 break; 3637 case 0x10: 3638 GETBYTE (); 3639 switch (op[3] & 0x00) 3640 { 3641 case 0x00: 3642 goto op_semantics_16; 3643 break; 3644 } 3645 break; 3646 case 0x11: 3647 GETBYTE (); 3648 switch (op[3] & 0x00) 3649 { 3650 case 0x00: 3651 goto op_semantics_17; 3652 break; 3653 } 3654 break; 3655 case 0x15: 3656 GETBYTE (); 3657 switch (op[3] & 0x00) 3658 { 3659 case 0x00: 3660 goto op_semantics_18; 3661 break; 3662 } 3663 break; 3664 default: UNSUPPORTED(); break; 3665 } 3666 break; 3667 default: UNSUPPORTED(); break; 3668 } 3669 break; 3670 case 0x08: 3671 case 0x09: 3672 case 0x0a: 3673 case 0x0b: 3674 case 0x0c: 3675 case 0x0d: 3676 case 0x0e: 3677 case 0x0f: 3678 { 3679 /** 0000 1dsp bra.s %a0 */ 3680 #line 800 "rx-decode.opc" 3681 int dsp AU = op[0] & 0x07; 3682 if (trace) 3683 { 3684 printf ("\033[33m%s\033[0m %02x\n", 3685 "/** 0000 1dsp bra.s %a0 */", 3686 op[0]); 3687 printf (" dsp = 0x%x\n", dsp); 3688 } 3689 SYNTAX("bra.s %a0"); 3690 #line 800 "rx-decode.opc" 3691 ID(branch); DC(pc + dsp3map[dsp]); 3692 3693 } 3694 break; 3695 case 0x10: 3696 case 0x11: 3697 case 0x12: 3698 case 0x13: 3699 case 0x14: 3700 case 0x15: 3701 case 0x16: 3702 case 0x17: 3703 case 0x18: 3704 case 0x19: 3705 case 0x1a: 3706 case 0x1b: 3707 case 0x1c: 3708 case 0x1d: 3709 case 0x1e: 3710 case 0x1f: 3711 { 3712 /** 0001 n dsp b%1.s %a0 */ 3713 #line 790 "rx-decode.opc" 3714 int n AU = (op[0] >> 3) & 0x01; 3715 #line 790 "rx-decode.opc" 3716 int dsp AU = op[0] & 0x07; 3717 if (trace) 3718 { 3719 printf ("\033[33m%s\033[0m %02x\n", 3720 "/** 0001 n dsp b%1.s %a0 */", 3721 op[0]); 3722 printf (" n = 0x%x,", n); 3723 printf (" dsp = 0x%x\n", dsp); 3724 } 3725 SYNTAX("b%1.s %a0"); 3726 #line 790 "rx-decode.opc" 3727 ID(branch); Scc(n); DC(pc + dsp3map[dsp]); 3728 3729 } 3730 break; 3731 case 0x20: 3732 case 0x21: 3733 case 0x22: 3734 case 0x23: 3735 case 0x24: 3736 case 0x25: 3737 case 0x26: 3738 case 0x27: 3739 case 0x28: 3740 case 0x29: 3741 case 0x2a: 3742 case 0x2b: 3743 case 0x2c: 3744 case 0x2d: 3745 case 0x2f: 3746 { 3747 /** 0010 cond b%1.b %a0 */ 3748 #line 793 "rx-decode.opc" 3749 int cond AU = op[0] & 0x0f; 3750 if (trace) 3751 { 3752 printf ("\033[33m%s\033[0m %02x\n", 3753 "/** 0010 cond b%1.b %a0 */", 3754 op[0]); 3755 printf (" cond = 0x%x\n", cond); 3756 } 3757 SYNTAX("b%1.b %a0"); 3758 #line 793 "rx-decode.opc" 3759 ID(branch); Scc(cond); DC(pc + IMMex (1)); 3760 3761 } 3762 break; 3763 case 0x2e: 3764 { 3765 /** 0010 1110 bra.b %a0 */ 3766 if (trace) 3767 { 3768 printf ("\033[33m%s\033[0m %02x\n", 3769 "/** 0010 1110 bra.b %a0 */", 3770 op[0]); 3771 } 3772 SYNTAX("bra.b %a0"); 3773 #line 803 "rx-decode.opc" 3774 ID(branch); DC(pc + IMMex(1)); 3775 3776 } 3777 break; 3778 case 0x38: 3779 { 3780 /** 0011 1000 bra.w %a0 */ 3781 if (trace) 3782 { 3783 printf ("\033[33m%s\033[0m %02x\n", 3784 "/** 0011 1000 bra.w %a0 */", 3785 op[0]); 3786 } 3787 SYNTAX("bra.w %a0"); 3788 #line 806 "rx-decode.opc" 3789 ID(branch); DC(pc + IMMex(2)); 3790 3791 } 3792 break; 3793 case 0x39: 3794 { 3795 /** 0011 1001 bsr.w %a0 */ 3796 if (trace) 3797 { 3798 printf ("\033[33m%s\033[0m %02x\n", 3799 "/** 0011 1001 bsr.w %a0 */", 3800 op[0]); 3801 } 3802 SYNTAX("bsr.w %a0"); 3803 #line 822 "rx-decode.opc" 3804 ID(jsr); DC(pc + IMMex(2)); 3805 3806 } 3807 break; 3808 case 0x3a: 3809 case 0x3b: 3810 { 3811 /** 0011 101c b%1.w %a0 */ 3812 #line 796 "rx-decode.opc" 3813 int c AU = op[0] & 0x01; 3814 if (trace) 3815 { 3816 printf ("\033[33m%s\033[0m %02x\n", 3817 "/** 0011 101c b%1.w %a0 */", 3818 op[0]); 3819 printf (" c = 0x%x\n", c); 3820 } 3821 SYNTAX("b%1.w %a0"); 3822 #line 796 "rx-decode.opc" 3823 ID(branch); Scc(c); DC(pc + IMMex (2)); 3824 3825 3826 } 3827 break; 3828 case 0x3c: 3829 GETBYTE (); 3830 switch (op[1] & 0x00) 3831 { 3832 case 0x00: 3833 op_semantics_20: 3834 { 3835 /** 0011 11sz d dst sppp mov%s #%1, %0 */ 3836 #line 332 "rx-decode.opc" 3837 int sz AU = op[0] & 0x03; 3838 #line 332 "rx-decode.opc" 3839 int d AU = (op[1] >> 7) & 0x01; 3840 #line 332 "rx-decode.opc" 3841 int dst AU = (op[1] >> 4) & 0x07; 3842 #line 332 "rx-decode.opc" 3843 int sppp AU = op[1] & 0x0f; 3844 if (trace) 3845 { 3846 printf ("\033[33m%s\033[0m %02x %02x\n", 3847 "/** 0011 11sz d dst sppp mov%s #%1, %0 */", 3848 op[0], op[1]); 3849 printf (" sz = 0x%x,", sz); 3850 printf (" d = 0x%x,", d); 3851 printf (" dst = 0x%x,", dst); 3852 printf (" sppp = 0x%x\n", sppp); 3853 } 3854 SYNTAX("mov%s #%1, %0"); 3855 #line 332 "rx-decode.opc" 3856 ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F_____; 3857 3858 } 3859 break; 3860 } 3861 break; 3862 case 0x3d: 3863 GETBYTE (); 3864 switch (op[1] & 0x00) 3865 { 3866 case 0x00: 3867 goto op_semantics_20; 3868 break; 3869 } 3870 break; 3871 case 0x3e: 3872 GETBYTE (); 3873 switch (op[1] & 0x00) 3874 { 3875 case 0x00: 3876 goto op_semantics_20; 3877 break; 3878 } 3879 break; 3880 case 0x3f: 3881 GETBYTE (); 3882 switch (op[1] & 0x00) 3883 { 3884 case 0x00: 3885 { 3886 /** 0011 1111 rega regb rtsd #%1, %2-%0 */ 3887 #line 429 "rx-decode.opc" 3888 int rega AU = (op[1] >> 4) & 0x0f; 3889 #line 429 "rx-decode.opc" 3890 int regb AU = op[1] & 0x0f; 3891 if (trace) 3892 { 3893 printf ("\033[33m%s\033[0m %02x %02x\n", 3894 "/** 0011 1111 rega regb rtsd #%1, %2-%0 */", 3895 op[0], op[1]); 3896 printf (" rega = 0x%x,", rega); 3897 printf (" regb = 0x%x\n", regb); 3898 } 3899 SYNTAX("rtsd #%1, %2-%0"); 3900 #line 429 "rx-decode.opc" 3901 ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb); 3902 3903 /*----------------------------------------------------------------------*/ 3904 /* AND */ 3905 3906 } 3907 break; 3908 } 3909 break; 3910 case 0x40: 3911 GETBYTE (); 3912 switch (op[1] & 0x00) 3913 { 3914 case 0x00: 3915 op_semantics_21: 3916 { 3917 /** 0100 00ss rsrc rdst sub %2%S2, %1 */ 3918 #line 564 "rx-decode.opc" 3919 int ss AU = op[0] & 0x03; 3920 #line 564 "rx-decode.opc" 3921 int rsrc AU = (op[1] >> 4) & 0x0f; 3922 #line 564 "rx-decode.opc" 3923 int rdst AU = op[1] & 0x0f; 3924 if (trace) 3925 { 3926 printf ("\033[33m%s\033[0m %02x %02x\n", 3927 "/** 0100 00ss rsrc rdst sub %2%S2, %1 */", 3928 op[0], op[1]); 3929 printf (" ss = 0x%x,", ss); 3930 printf (" rsrc = 0x%x,", rsrc); 3931 printf (" rdst = 0x%x\n", rdst); 3932 } 3933 SYNTAX("sub %2%S2, %1"); 3934 #line 564 "rx-decode.opc" 3935 ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F_OSZC; 3936 3937 } 3938 break; 3939 } 3940 break; 3941 case 0x41: 3942 GETBYTE (); 3943 switch (op[1] & 0x00) 3944 { 3945 case 0x00: 3946 goto op_semantics_21; 3947 break; 3948 } 3949 break; 3950 case 0x42: 3951 GETBYTE (); 3952 switch (op[1] & 0x00) 3953 { 3954 case 0x00: 3955 goto op_semantics_21; 3956 break; 3957 } 3958 break; 3959 case 0x43: 3960 GETBYTE (); 3961 switch (op[1] & 0x00) 3962 { 3963 case 0x00: 3964 goto op_semantics_21; 3965 break; 3966 } 3967 break; 3968 case 0x44: 3969 GETBYTE (); 3970 switch (op[1] & 0x00) 3971 { 3972 case 0x00: 3973 op_semantics_22: 3974 { 3975 /** 0100 01ss rsrc rdst cmp %2%S2, %1 */ 3976 #line 552 "rx-decode.opc" 3977 int ss AU = op[0] & 0x03; 3978 #line 552 "rx-decode.opc" 3979 int rsrc AU = (op[1] >> 4) & 0x0f; 3980 #line 552 "rx-decode.opc" 3981 int rdst AU = op[1] & 0x0f; 3982 if (trace) 3983 { 3984 printf ("\033[33m%s\033[0m %02x %02x\n", 3985 "/** 0100 01ss rsrc rdst cmp %2%S2, %1 */", 3986 op[0], op[1]); 3987 printf (" ss = 0x%x,", ss); 3988 printf (" rsrc = 0x%x,", rsrc); 3989 printf (" rdst = 0x%x\n", rdst); 3990 } 3991 SYNTAX("cmp %2%S2, %1"); 3992 #line 552 "rx-decode.opc" 3993 ID(sub); S2P(ss, rsrc); SR(rdst); F_OSZC; 3994 3995 } 3996 break; 3997 } 3998 break; 3999 case 0x45: 4000 GETBYTE (); 4001 switch (op[1] & 0x00) 4002 { 4003 case 0x00: 4004 goto op_semantics_22; 4005 break; 4006 } 4007 break; 4008 case 0x46: 4009 GETBYTE (); 4010 switch (op[1] & 0x00) 4011 { 4012 case 0x00: 4013 goto op_semantics_22; 4014 break; 4015 } 4016 break; 4017 case 0x47: 4018 GETBYTE (); 4019 switch (op[1] & 0x00) 4020 { 4021 case 0x00: 4022 goto op_semantics_22; 4023 break; 4024 } 4025 break; 4026 case 0x48: 4027 GETBYTE (); 4028 switch (op[1] & 0x00) 4029 { 4030 case 0x00: 4031 op_semantics_23: 4032 { 4033 /** 0100 10ss rsrc rdst add %1%S1, %0 */ 4034 #line 528 "rx-decode.opc" 4035 int ss AU = op[0] & 0x03; 4036 #line 528 "rx-decode.opc" 4037 int rsrc AU = (op[1] >> 4) & 0x0f; 4038 #line 528 "rx-decode.opc" 4039 int rdst AU = op[1] & 0x0f; 4040 if (trace) 4041 { 4042 printf ("\033[33m%s\033[0m %02x %02x\n", 4043 "/** 0100 10ss rsrc rdst add %1%S1, %0 */", 4044 op[0], op[1]); 4045 printf (" ss = 0x%x,", ss); 4046 printf (" rsrc = 0x%x,", rsrc); 4047 printf (" rdst = 0x%x\n", rdst); 4048 } 4049 SYNTAX("add %1%S1, %0"); 4050 #line 528 "rx-decode.opc" 4051 ID(add); SP(ss, rsrc); DR(rdst); F_OSZC; 4052 4053 } 4054 break; 4055 } 4056 break; 4057 case 0x49: 4058 GETBYTE (); 4059 switch (op[1] & 0x00) 4060 { 4061 case 0x00: 4062 goto op_semantics_23; 4063 break; 4064 } 4065 break; 4066 case 0x4a: 4067 GETBYTE (); 4068 switch (op[1] & 0x00) 4069 { 4070 case 0x00: 4071 goto op_semantics_23; 4072 break; 4073 } 4074 break; 4075 case 0x4b: 4076 GETBYTE (); 4077 switch (op[1] & 0x00) 4078 { 4079 case 0x00: 4080 goto op_semantics_23; 4081 break; 4082 } 4083 break; 4084 case 0x4c: 4085 GETBYTE (); 4086 switch (op[1] & 0x00) 4087 { 4088 case 0x00: 4089 op_semantics_24: 4090 { 4091 /** 0100 11ss rsrc rdst mul %1%S1, %0 */ 4092 #line 671 "rx-decode.opc" 4093 int ss AU = op[0] & 0x03; 4094 #line 671 "rx-decode.opc" 4095 int rsrc AU = (op[1] >> 4) & 0x0f; 4096 #line 671 "rx-decode.opc" 4097 int rdst AU = op[1] & 0x0f; 4098 if (trace) 4099 { 4100 printf ("\033[33m%s\033[0m %02x %02x\n", 4101 "/** 0100 11ss rsrc rdst mul %1%S1, %0 */", 4102 op[0], op[1]); 4103 printf (" ss = 0x%x,", ss); 4104 printf (" rsrc = 0x%x,", rsrc); 4105 printf (" rdst = 0x%x\n", rdst); 4106 } 4107 SYNTAX("mul %1%S1, %0"); 4108 #line 671 "rx-decode.opc" 4109 ID(mul); SP(ss, rsrc); DR(rdst); F_____; 4110 4111 } 4112 break; 4113 } 4114 break; 4115 case 0x4d: 4116 GETBYTE (); 4117 switch (op[1] & 0x00) 4118 { 4119 case 0x00: 4120 goto op_semantics_24; 4121 break; 4122 } 4123 break; 4124 case 0x4e: 4125 GETBYTE (); 4126 switch (op[1] & 0x00) 4127 { 4128 case 0x00: 4129 goto op_semantics_24; 4130 break; 4131 } 4132 break; 4133 case 0x4f: 4134 GETBYTE (); 4135 switch (op[1] & 0x00) 4136 { 4137 case 0x00: 4138 goto op_semantics_24; 4139 break; 4140 } 4141 break; 4142 case 0x50: 4143 GETBYTE (); 4144 switch (op[1] & 0x00) 4145 { 4146 case 0x00: 4147 op_semantics_25: 4148 { 4149 /** 0101 00ss rsrc rdst and %1%S1, %0 */ 4150 #line 441 "rx-decode.opc" 4151 int ss AU = op[0] & 0x03; 4152 #line 441 "rx-decode.opc" 4153 int rsrc AU = (op[1] >> 4) & 0x0f; 4154 #line 441 "rx-decode.opc" 4155 int rdst AU = op[1] & 0x0f; 4156 if (trace) 4157 { 4158 printf ("\033[33m%s\033[0m %02x %02x\n", 4159 "/** 0101 00ss rsrc rdst and %1%S1, %0 */", 4160 op[0], op[1]); 4161 printf (" ss = 0x%x,", ss); 4162 printf (" rsrc = 0x%x,", rsrc); 4163 printf (" rdst = 0x%x\n", rdst); 4164 } 4165 SYNTAX("and %1%S1, %0"); 4166 #line 441 "rx-decode.opc" 4167 ID(and); SP(ss, rsrc); DR(rdst); F__SZ_; 4168 4169 } 4170 break; 4171 } 4172 break; 4173 case 0x51: 4174 GETBYTE (); 4175 switch (op[1] & 0x00) 4176 { 4177 case 0x00: 4178 goto op_semantics_25; 4179 break; 4180 } 4181 break; 4182 case 0x52: 4183 GETBYTE (); 4184 switch (op[1] & 0x00) 4185 { 4186 case 0x00: 4187 goto op_semantics_25; 4188 break; 4189 } 4190 break; 4191 case 0x53: 4192 GETBYTE (); 4193 switch (op[1] & 0x00) 4194 { 4195 case 0x00: 4196 goto op_semantics_25; 4197 break; 4198 } 4199 break; 4200 case 0x54: 4201 GETBYTE (); 4202 switch (op[1] & 0x00) 4203 { 4204 case 0x00: 4205 op_semantics_26: 4206 { 4207 /** 0101 01ss rsrc rdst or %1%S1, %0 */ 4208 #line 459 "rx-decode.opc" 4209 int ss AU = op[0] & 0x03; 4210 #line 459 "rx-decode.opc" 4211 int rsrc AU = (op[1] >> 4) & 0x0f; 4212 #line 459 "rx-decode.opc" 4213 int rdst AU = op[1] & 0x0f; 4214 if (trace) 4215 { 4216 printf ("\033[33m%s\033[0m %02x %02x\n", 4217 "/** 0101 01ss rsrc rdst or %1%S1, %0 */", 4218 op[0], op[1]); 4219 printf (" ss = 0x%x,", ss); 4220 printf (" rsrc = 0x%x,", rsrc); 4221 printf (" rdst = 0x%x\n", rdst); 4222 } 4223 SYNTAX("or %1%S1, %0"); 4224 #line 459 "rx-decode.opc" 4225 ID(or); SP(ss, rsrc); DR(rdst); F__SZ_; 4226 4227 } 4228 break; 4229 } 4230 break; 4231 case 0x55: 4232 GETBYTE (); 4233 switch (op[1] & 0x00) 4234 { 4235 case 0x00: 4236 goto op_semantics_26; 4237 break; 4238 } 4239 break; 4240 case 0x56: 4241 GETBYTE (); 4242 switch (op[1] & 0x00) 4243 { 4244 case 0x00: 4245 goto op_semantics_26; 4246 break; 4247 } 4248 break; 4249 case 0x57: 4250 GETBYTE (); 4251 switch (op[1] & 0x00) 4252 { 4253 case 0x00: 4254 goto op_semantics_26; 4255 break; 4256 } 4257 break; 4258 case 0x58: 4259 GETBYTE (); 4260 switch (op[1] & 0x00) 4261 { 4262 case 0x00: 4263 op_semantics_27: 4264 { 4265 /** 0101 1 s ss rsrc rdst movu%s %1, %0 */ 4266 #line 380 "rx-decode.opc" 4267 int s AU = (op[0] >> 2) & 0x01; 4268 #line 380 "rx-decode.opc" 4269 int ss AU = op[0] & 0x03; 4270 #line 380 "rx-decode.opc" 4271 int rsrc AU = (op[1] >> 4) & 0x0f; 4272 #line 380 "rx-decode.opc" 4273 int rdst AU = op[1] & 0x0f; 4274 if (trace) 4275 { 4276 printf ("\033[33m%s\033[0m %02x %02x\n", 4277 "/** 0101 1 s ss rsrc rdst movu%s %1, %0 */", 4278 op[0], op[1]); 4279 printf (" s = 0x%x,", s); 4280 printf (" ss = 0x%x,", ss); 4281 printf (" rsrc = 0x%x,", rsrc); 4282 printf (" rdst = 0x%x\n", rdst); 4283 } 4284 SYNTAX("movu%s %1, %0"); 4285 #line 380 "rx-decode.opc" 4286 ID(mov); uBW(s); SD(ss, rsrc, s); DR(rdst); F_____; 4287 4288 } 4289 break; 4290 } 4291 break; 4292 case 0x59: 4293 GETBYTE (); 4294 switch (op[1] & 0x00) 4295 { 4296 case 0x00: 4297 goto op_semantics_27; 4298 break; 4299 } 4300 break; 4301 case 0x5a: 4302 GETBYTE (); 4303 switch (op[1] & 0x00) 4304 { 4305 case 0x00: 4306 goto op_semantics_27; 4307 break; 4308 } 4309 break; 4310 case 0x5b: 4311 GETBYTE (); 4312 switch (op[1] & 0x00) 4313 { 4314 case 0x00: 4315 goto op_semantics_27; 4316 break; 4317 } 4318 break; 4319 case 0x5c: 4320 GETBYTE (); 4321 switch (op[1] & 0x00) 4322 { 4323 case 0x00: 4324 goto op_semantics_27; 4325 break; 4326 } 4327 break; 4328 case 0x5d: 4329 GETBYTE (); 4330 switch (op[1] & 0x00) 4331 { 4332 case 0x00: 4333 goto op_semantics_27; 4334 break; 4335 } 4336 break; 4337 case 0x5e: 4338 GETBYTE (); 4339 switch (op[1] & 0x00) 4340 { 4341 case 0x00: 4342 goto op_semantics_27; 4343 break; 4344 } 4345 break; 4346 case 0x5f: 4347 GETBYTE (); 4348 switch (op[1] & 0x00) 4349 { 4350 case 0x00: 4351 goto op_semantics_27; 4352 break; 4353 } 4354 break; 4355 case 0x60: 4356 GETBYTE (); 4357 switch (op[1] & 0x00) 4358 { 4359 case 0x00: 4360 { 4361 /** 0110 0000 immm rdst sub #%2, %0 */ 4362 #line 561 "rx-decode.opc" 4363 int immm AU = (op[1] >> 4) & 0x0f; 4364 #line 561 "rx-decode.opc" 4365 int rdst AU = op[1] & 0x0f; 4366 if (trace) 4367 { 4368 printf ("\033[33m%s\033[0m %02x %02x\n", 4369 "/** 0110 0000 immm rdst sub #%2, %0 */", 4370 op[0], op[1]); 4371 printf (" immm = 0x%x,", immm); 4372 printf (" rdst = 0x%x\n", rdst); 4373 } 4374 SYNTAX("sub #%2, %0"); 4375 #line 561 "rx-decode.opc" 4376 ID(sub); S2C(immm); SR(rdst); DR(rdst); F_OSZC; 4377 4378 } 4379 break; 4380 } 4381 break; 4382 case 0x61: 4383 GETBYTE (); 4384 switch (op[1] & 0x00) 4385 { 4386 case 0x00: 4387 { 4388 /** 0110 0001 immm rdst cmp #%2, %1 */ 4389 #line 543 "rx-decode.opc" 4390 int immm AU = (op[1] >> 4) & 0x0f; 4391 #line 543 "rx-decode.opc" 4392 int rdst AU = op[1] & 0x0f; 4393 if (trace) 4394 { 4395 printf ("\033[33m%s\033[0m %02x %02x\n", 4396 "/** 0110 0001 immm rdst cmp #%2, %1 */", 4397 op[0], op[1]); 4398 printf (" immm = 0x%x,", immm); 4399 printf (" rdst = 0x%x\n", rdst); 4400 } 4401 SYNTAX("cmp #%2, %1"); 4402 #line 543 "rx-decode.opc" 4403 ID(sub); S2C(immm); SR(rdst); F_OSZC; 4404 4405 } 4406 break; 4407 } 4408 break; 4409 case 0x62: 4410 GETBYTE (); 4411 switch (op[1] & 0x00) 4412 { 4413 case 0x00: 4414 { 4415 /** 0110 0010 immm rdst add #%1, %0 */ 4416 #line 525 "rx-decode.opc" 4417 int immm AU = (op[1] >> 4) & 0x0f; 4418 #line 525 "rx-decode.opc" 4419 int rdst AU = op[1] & 0x0f; 4420 if (trace) 4421 { 4422 printf ("\033[33m%s\033[0m %02x %02x\n", 4423 "/** 0110 0010 immm rdst add #%1, %0 */", 4424 op[0], op[1]); 4425 printf (" immm = 0x%x,", immm); 4426 printf (" rdst = 0x%x\n", rdst); 4427 } 4428 SYNTAX("add #%1, %0"); 4429 #line 525 "rx-decode.opc" 4430 ID(add); SC(immm); DR(rdst); F_OSZC; 4431 4432 } 4433 break; 4434 } 4435 break; 4436 case 0x63: 4437 GETBYTE (); 4438 switch (op[1] & 0x00) 4439 { 4440 case 0x00: 4441 { 4442 /** 0110 0011 immm rdst mul #%1, %0 */ 4443 #line 637 "rx-decode.opc" 4444 int immm AU = (op[1] >> 4) & 0x0f; 4445 #line 637 "rx-decode.opc" 4446 int rdst AU = op[1] & 0x0f; 4447 if (trace) 4448 { 4449 printf ("\033[33m%s\033[0m %02x %02x\n", 4450 "/** 0110 0011 immm rdst mul #%1, %0 */", 4451 op[0], op[1]); 4452 printf (" immm = 0x%x,", immm); 4453 printf (" rdst = 0x%x\n", rdst); 4454 } 4455 SYNTAX("mul #%1, %0"); 4456 #line 637 "rx-decode.opc" 4457 if (immm == 1 && rdst == 0) 4458 { 4459 ID(nop2); 4460 SYNTAX ("nop\t; mul\t#1, r0"); 4461 } 4462 else 4463 { 4464 ID(mul); 4465 } 4466 DR(rdst); SC(immm); F_____; 4467 4468 } 4469 break; 4470 } 4471 break; 4472 case 0x64: 4473 GETBYTE (); 4474 switch (op[1] & 0x00) 4475 { 4476 case 0x00: 4477 { 4478 /** 0110 0100 immm rdst and #%1, %0 */ 4479 #line 435 "rx-decode.opc" 4480 int immm AU = (op[1] >> 4) & 0x0f; 4481 #line 435 "rx-decode.opc" 4482 int rdst AU = op[1] & 0x0f; 4483 if (trace) 4484 { 4485 printf ("\033[33m%s\033[0m %02x %02x\n", 4486 "/** 0110 0100 immm rdst and #%1, %0 */", 4487 op[0], op[1]); 4488 printf (" immm = 0x%x,", immm); 4489 printf (" rdst = 0x%x\n", rdst); 4490 } 4491 SYNTAX("and #%1, %0"); 4492 #line 435 "rx-decode.opc" 4493 ID(and); SC(immm); DR(rdst); F__SZ_; 4494 4495 } 4496 break; 4497 } 4498 break; 4499 case 0x65: 4500 GETBYTE (); 4501 switch (op[1] & 0x00) 4502 { 4503 case 0x00: 4504 { 4505 /** 0110 0101 immm rdst or #%1, %0 */ 4506 #line 453 "rx-decode.opc" 4507 int immm AU = (op[1] >> 4) & 0x0f; 4508 #line 453 "rx-decode.opc" 4509 int rdst AU = op[1] & 0x0f; 4510 if (trace) 4511 { 4512 printf ("\033[33m%s\033[0m %02x %02x\n", 4513 "/** 0110 0101 immm rdst or #%1, %0 */", 4514 op[0], op[1]); 4515 printf (" immm = 0x%x,", immm); 4516 printf (" rdst = 0x%x\n", rdst); 4517 } 4518 SYNTAX("or #%1, %0"); 4519 #line 453 "rx-decode.opc" 4520 ID(or); SC(immm); DR(rdst); F__SZ_; 4521 4522 } 4523 break; 4524 } 4525 break; 4526 case 0x66: 4527 GETBYTE (); 4528 switch (op[1] & 0x00) 4529 { 4530 case 0x00: 4531 { 4532 /** 0110 0110 immm rdst mov%s #%1, %0 */ 4533 #line 329 "rx-decode.opc" 4534 int immm AU = (op[1] >> 4) & 0x0f; 4535 #line 329 "rx-decode.opc" 4536 int rdst AU = op[1] & 0x0f; 4537 if (trace) 4538 { 4539 printf ("\033[33m%s\033[0m %02x %02x\n", 4540 "/** 0110 0110 immm rdst mov%s #%1, %0 */", 4541 op[0], op[1]); 4542 printf (" immm = 0x%x,", immm); 4543 printf (" rdst = 0x%x\n", rdst); 4544 } 4545 SYNTAX("mov%s #%1, %0"); 4546 #line 329 "rx-decode.opc" 4547 ID(mov); DR(rdst); SC(immm); F_____; 4548 4549 } 4550 break; 4551 } 4552 break; 4553 case 0x67: 4554 { 4555 /** 0110 0111 rtsd #%1 */ 4556 if (trace) 4557 { 4558 printf ("\033[33m%s\033[0m %02x\n", 4559 "/** 0110 0111 rtsd #%1 */", 4560 op[0]); 4561 } 4562 SYNTAX("rtsd #%1"); 4563 #line 426 "rx-decode.opc" 4564 ID(rtsd); SC(IMM(1) * 4); 4565 4566 } 4567 break; 4568 case 0x68: 4569 GETBYTE (); 4570 switch (op[1] & 0x00) 4571 { 4572 case 0x00: 4573 op_semantics_28: 4574 { 4575 /** 0110 100i mmmm rdst shlr #%2, %0 */ 4576 #line 751 "rx-decode.opc" 4577 int i AU = op[0] & 0x01; 4578 #line 751 "rx-decode.opc" 4579 int mmmm AU = (op[1] >> 4) & 0x0f; 4580 #line 751 "rx-decode.opc" 4581 int rdst AU = op[1] & 0x0f; 4582 if (trace) 4583 { 4584 printf ("\033[33m%s\033[0m %02x %02x\n", 4585 "/** 0110 100i mmmm rdst shlr #%2, %0 */", 4586 op[0], op[1]); 4587 printf (" i = 0x%x,", i); 4588 printf (" mmmm = 0x%x,", mmmm); 4589 printf (" rdst = 0x%x\n", rdst); 4590 } 4591 SYNTAX("shlr #%2, %0"); 4592 #line 751 "rx-decode.opc" 4593 ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F__SZC; 4594 4595 } 4596 break; 4597 } 4598 break; 4599 case 0x69: 4600 GETBYTE (); 4601 switch (op[1] & 0x00) 4602 { 4603 case 0x00: 4604 goto op_semantics_28; 4605 break; 4606 } 4607 break; 4608 case 0x6a: 4609 GETBYTE (); 4610 switch (op[1] & 0x00) 4611 { 4612 case 0x00: 4613 op_semantics_29: 4614 { 4615 /** 0110 101i mmmm rdst shar #%2, %0 */ 4616 #line 741 "rx-decode.opc" 4617 int i AU = op[0] & 0x01; 4618 #line 741 "rx-decode.opc" 4619 int mmmm AU = (op[1] >> 4) & 0x0f; 4620 #line 741 "rx-decode.opc" 4621 int rdst AU = op[1] & 0x0f; 4622 if (trace) 4623 { 4624 printf ("\033[33m%s\033[0m %02x %02x\n", 4625 "/** 0110 101i mmmm rdst shar #%2, %0 */", 4626 op[0], op[1]); 4627 printf (" i = 0x%x,", i); 4628 printf (" mmmm = 0x%x,", mmmm); 4629 printf (" rdst = 0x%x\n", rdst); 4630 } 4631 SYNTAX("shar #%2, %0"); 4632 #line 741 "rx-decode.opc" 4633 ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_0SZC; 4634 4635 } 4636 break; 4637 } 4638 break; 4639 case 0x6b: 4640 GETBYTE (); 4641 switch (op[1] & 0x00) 4642 { 4643 case 0x00: 4644 goto op_semantics_29; 4645 break; 4646 } 4647 break; 4648 case 0x6c: 4649 GETBYTE (); 4650 switch (op[1] & 0x00) 4651 { 4652 case 0x00: 4653 op_semantics_30: 4654 { 4655 /** 0110 110i mmmm rdst shll #%2, %0 */ 4656 #line 731 "rx-decode.opc" 4657 int i AU = op[0] & 0x01; 4658 #line 731 "rx-decode.opc" 4659 int mmmm AU = (op[1] >> 4) & 0x0f; 4660 #line 731 "rx-decode.opc" 4661 int rdst AU = op[1] & 0x0f; 4662 if (trace) 4663 { 4664 printf ("\033[33m%s\033[0m %02x %02x\n", 4665 "/** 0110 110i mmmm rdst shll #%2, %0 */", 4666 op[0], op[1]); 4667 printf (" i = 0x%x,", i); 4668 printf (" mmmm = 0x%x,", mmmm); 4669 printf (" rdst = 0x%x\n", rdst); 4670 } 4671 SYNTAX("shll #%2, %0"); 4672 #line 731 "rx-decode.opc" 4673 ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_OSZC; 4674 4675 } 4676 break; 4677 } 4678 break; 4679 case 0x6d: 4680 GETBYTE (); 4681 switch (op[1] & 0x00) 4682 { 4683 case 0x00: 4684 goto op_semantics_30; 4685 break; 4686 } 4687 break; 4688 case 0x6e: 4689 GETBYTE (); 4690 switch (op[1] & 0x00) 4691 { 4692 case 0x00: 4693 { 4694 /** 0110 1110 dsta dstb pushm %1-%2 */ 4695 #line 393 "rx-decode.opc" 4696 int dsta AU = (op[1] >> 4) & 0x0f; 4697 #line 393 "rx-decode.opc" 4698 int dstb AU = op[1] & 0x0f; 4699 if (trace) 4700 { 4701 printf ("\033[33m%s\033[0m %02x %02x\n", 4702 "/** 0110 1110 dsta dstb pushm %1-%2 */", 4703 op[0], op[1]); 4704 printf (" dsta = 0x%x,", dsta); 4705 printf (" dstb = 0x%x\n", dstb); 4706 } 4707 SYNTAX("pushm %1-%2"); 4708 #line 393 "rx-decode.opc" 4709 ID(pushm); SR(dsta); S2R(dstb); F_____; 4710 4711 } 4712 break; 4713 } 4714 break; 4715 case 0x6f: 4716 GETBYTE (); 4717 switch (op[1] & 0x00) 4718 { 4719 case 0x00: 4720 { 4721 /** 0110 1111 dsta dstb popm %1-%2 */ 4722 #line 390 "rx-decode.opc" 4723 int dsta AU = (op[1] >> 4) & 0x0f; 4724 #line 390 "rx-decode.opc" 4725 int dstb AU = op[1] & 0x0f; 4726 if (trace) 4727 { 4728 printf ("\033[33m%s\033[0m %02x %02x\n", 4729 "/** 0110 1111 dsta dstb popm %1-%2 */", 4730 op[0], op[1]); 4731 printf (" dsta = 0x%x,", dsta); 4732 printf (" dstb = 0x%x\n", dstb); 4733 } 4734 SYNTAX("popm %1-%2"); 4735 #line 390 "rx-decode.opc" 4736 ID(popm); SR(dsta); S2R(dstb); F_____; 4737 4738 } 4739 break; 4740 } 4741 break; 4742 case 0x70: 4743 GETBYTE (); 4744 switch (op[1] & 0x00) 4745 { 4746 case 0x00: 4747 op_semantics_31: 4748 { 4749 /** 0111 00im rsrc rdst add #%1, %2, %0 */ 4750 #line 534 "rx-decode.opc" 4751 int im AU = op[0] & 0x03; 4752 #line 534 "rx-decode.opc" 4753 int rsrc AU = (op[1] >> 4) & 0x0f; 4754 #line 534 "rx-decode.opc" 4755 int rdst AU = op[1] & 0x0f; 4756 if (trace) 4757 { 4758 printf ("\033[33m%s\033[0m %02x %02x\n", 4759 "/** 0111 00im rsrc rdst add #%1, %2, %0 */", 4760 op[0], op[1]); 4761 printf (" im = 0x%x,", im); 4762 printf (" rsrc = 0x%x,", rsrc); 4763 printf (" rdst = 0x%x\n", rdst); 4764 } 4765 SYNTAX("add #%1, %2, %0"); 4766 #line 534 "rx-decode.opc" 4767 ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F_OSZC; 4768 4769 } 4770 break; 4771 } 4772 break; 4773 case 0x71: 4774 GETBYTE (); 4775 switch (op[1] & 0x00) 4776 { 4777 case 0x00: 4778 goto op_semantics_31; 4779 break; 4780 } 4781 break; 4782 case 0x72: 4783 GETBYTE (); 4784 switch (op[1] & 0x00) 4785 { 4786 case 0x00: 4787 goto op_semantics_31; 4788 break; 4789 } 4790 break; 4791 case 0x73: 4792 GETBYTE (); 4793 switch (op[1] & 0x00) 4794 { 4795 case 0x00: 4796 goto op_semantics_31; 4797 break; 4798 } 4799 break; 4800 case 0x74: 4801 GETBYTE (); 4802 switch (op[1] & 0xf0) 4803 { 4804 case 0x00: 4805 op_semantics_32: 4806 { 4807 /** 0111 01im 0000 rsrc cmp #%2, %1%S1 */ 4808 #line 546 "rx-decode.opc" 4809 int im AU = op[0] & 0x03; 4810 #line 546 "rx-decode.opc" 4811 int rsrc AU = op[1] & 0x0f; 4812 if (trace) 4813 { 4814 printf ("\033[33m%s\033[0m %02x %02x\n", 4815 "/** 0111 01im 0000 rsrc cmp #%2, %1%S1 */", 4816 op[0], op[1]); 4817 printf (" im = 0x%x,", im); 4818 printf (" rsrc = 0x%x\n", rsrc); 4819 } 4820 SYNTAX("cmp #%2, %1%S1"); 4821 #line 546 "rx-decode.opc" 4822 ID(sub); SR(rsrc); S2C(IMMex(im)); F_OSZC; 4823 4824 } 4825 break; 4826 case 0x10: 4827 op_semantics_33: 4828 { 4829 /** 0111 01im 0001rdst mul #%1, %0 */ 4830 #line 649 "rx-decode.opc" 4831 int im AU = op[0] & 0x03; 4832 #line 649 "rx-decode.opc" 4833 int rdst AU = op[1] & 0x0f; 4834 if (trace) 4835 { 4836 printf ("\033[33m%s\033[0m %02x %02x\n", 4837 "/** 0111 01im 0001rdst mul #%1, %0 */", 4838 op[0], op[1]); 4839 printf (" im = 0x%x,", im); 4840 printf (" rdst = 0x%x\n", rdst); 4841 } 4842 SYNTAX("mul #%1, %0"); 4843 #line 649 "rx-decode.opc" 4844 int val = IMMex(im); 4845 if (val == 1 && rdst == 0) 4846 { 4847 SYNTAX("nop\t; mul\t#1, r0"); 4848 switch (im) 4849 { 4850 case 2: ID(nop4); break; 4851 case 3: ID(nop5); break; 4852 case 0: ID(nop6); break; 4853 default: 4854 ID(mul); 4855 SYNTAX("mul #%1, %0"); 4856 break; 4857 } 4858 } 4859 else 4860 { 4861 ID(mul); 4862 } 4863 DR(rdst); SC(val); F_____; 4864 4865 } 4866 break; 4867 case 0x20: 4868 op_semantics_34: 4869 { 4870 /** 0111 01im 0010 rdst and #%1, %0 */ 4871 #line 438 "rx-decode.opc" 4872 int im AU = op[0] & 0x03; 4873 #line 438 "rx-decode.opc" 4874 int rdst AU = op[1] & 0x0f; 4875 if (trace) 4876 { 4877 printf ("\033[33m%s\033[0m %02x %02x\n", 4878 "/** 0111 01im 0010 rdst and #%1, %0 */", 4879 op[0], op[1]); 4880 printf (" im = 0x%x,", im); 4881 printf (" rdst = 0x%x\n", rdst); 4882 } 4883 SYNTAX("and #%1, %0"); 4884 #line 438 "rx-decode.opc" 4885 ID(and); SC(IMMex(im)); DR(rdst); F__SZ_; 4886 4887 } 4888 break; 4889 case 0x30: 4890 op_semantics_35: 4891 { 4892 /** 0111 01im 0011 rdst or #%1, %0 */ 4893 #line 456 "rx-decode.opc" 4894 int im AU = op[0] & 0x03; 4895 #line 456 "rx-decode.opc" 4896 int rdst AU = op[1] & 0x0f; 4897 if (trace) 4898 { 4899 printf ("\033[33m%s\033[0m %02x %02x\n", 4900 "/** 0111 01im 0011 rdst or #%1, %0 */", 4901 op[0], op[1]); 4902 printf (" im = 0x%x,", im); 4903 printf (" rdst = 0x%x\n", rdst); 4904 } 4905 SYNTAX("or #%1, %0"); 4906 #line 456 "rx-decode.opc" 4907 ID(or); SC(IMMex(im)); DR(rdst); F__SZ_; 4908 4909 } 4910 break; 4911 default: UNSUPPORTED(); break; 4912 } 4913 break; 4914 case 0x75: 4915 GETBYTE (); 4916 switch (op[1] & 0xff) 4917 { 4918 case 0x00: 4919 case 0x01: 4920 case 0x02: 4921 case 0x03: 4922 case 0x04: 4923 case 0x05: 4924 case 0x06: 4925 case 0x07: 4926 case 0x08: 4927 case 0x09: 4928 case 0x0a: 4929 case 0x0b: 4930 case 0x0c: 4931 case 0x0d: 4932 case 0x0e: 4933 case 0x0f: 4934 goto op_semantics_32; 4935 break; 4936 case 0x10: 4937 case 0x11: 4938 case 0x12: 4939 case 0x13: 4940 case 0x14: 4941 case 0x15: 4942 case 0x16: 4943 case 0x17: 4944 case 0x18: 4945 case 0x19: 4946 case 0x1a: 4947 case 0x1b: 4948 case 0x1c: 4949 case 0x1d: 4950 case 0x1e: 4951 case 0x1f: 4952 goto op_semantics_33; 4953 break; 4954 case 0x20: 4955 case 0x21: 4956 case 0x22: 4957 case 0x23: 4958 case 0x24: 4959 case 0x25: 4960 case 0x26: 4961 case 0x27: 4962 case 0x28: 4963 case 0x29: 4964 case 0x2a: 4965 case 0x2b: 4966 case 0x2c: 4967 case 0x2d: 4968 case 0x2e: 4969 case 0x2f: 4970 goto op_semantics_34; 4971 break; 4972 case 0x30: 4973 case 0x31: 4974 case 0x32: 4975 case 0x33: 4976 case 0x34: 4977 case 0x35: 4978 case 0x36: 4979 case 0x37: 4980 case 0x38: 4981 case 0x39: 4982 case 0x3a: 4983 case 0x3b: 4984 case 0x3c: 4985 case 0x3d: 4986 case 0x3e: 4987 case 0x3f: 4988 goto op_semantics_35; 4989 break; 4990 case 0x40: 4991 case 0x41: 4992 case 0x42: 4993 case 0x43: 4994 case 0x44: 4995 case 0x45: 4996 case 0x46: 4997 case 0x47: 4998 case 0x48: 4999 case 0x49: 5000 case 0x4a: 5001 case 0x4b: 5002 case 0x4c: 5003 case 0x4d: 5004 case 0x4e: 5005 case 0x4f: 5006 { 5007 /** 0111 0101 0100 rdst mov%s #%1, %0 */ 5008 #line 310 "rx-decode.opc" 5009 int rdst AU = op[1] & 0x0f; 5010 if (trace) 5011 { 5012 printf ("\033[33m%s\033[0m %02x %02x\n", 5013 "/** 0111 0101 0100 rdst mov%s #%1, %0 */", 5014 op[0], op[1]); 5015 printf (" rdst = 0x%x\n", rdst); 5016 } 5017 SYNTAX("mov%s #%1, %0"); 5018 #line 310 "rx-decode.opc" 5019 ID(mov); DR(rdst); SC(IMM (1)); F_____; 5020 5021 } 5022 break; 5023 case 0x50: 5024 case 0x51: 5025 case 0x52: 5026 case 0x53: 5027 case 0x54: 5028 case 0x55: 5029 case 0x56: 5030 case 0x57: 5031 case 0x58: 5032 case 0x59: 5033 case 0x5a: 5034 case 0x5b: 5035 case 0x5c: 5036 case 0x5d: 5037 case 0x5e: 5038 case 0x5f: 5039 { 5040 /** 0111 0101 0101 rsrc cmp #%2, %1 */ 5041 #line 549 "rx-decode.opc" 5042 int rsrc AU = op[1] & 0x0f; 5043 if (trace) 5044 { 5045 printf ("\033[33m%s\033[0m %02x %02x\n", 5046 "/** 0111 0101 0101 rsrc cmp #%2, %1 */", 5047 op[0], op[1]); 5048 printf (" rsrc = 0x%x\n", rsrc); 5049 } 5050 SYNTAX("cmp #%2, %1"); 5051 #line 549 "rx-decode.opc" 5052 ID(sub); SR(rsrc); S2C(IMM(1)); F_OSZC; 5053 5054 } 5055 break; 5056 case 0x60: 5057 { 5058 /** 0111 0101 0110 0000 int #%1 */ 5059 if (trace) 5060 { 5061 printf ("\033[33m%s\033[0m %02x %02x\n", 5062 "/** 0111 0101 0110 0000 int #%1 */", 5063 op[0], op[1]); 5064 } 5065 SYNTAX("int #%1"); 5066 #line 1056 "rx-decode.opc" 5067 ID(int); SC(IMM(1)); 5068 5069 } 5070 break; 5071 case 0x70: 5072 GETBYTE (); 5073 switch (op[2] & 0xf0) 5074 { 5075 case 0x00: 5076 { 5077 /** 0111 0101 0111 0000 0000 immm mvtipl #%1 */ 5078 #line 1023 "rx-decode.opc" 5079 int immm AU = op[2] & 0x0f; 5080 if (trace) 5081 { 5082 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 5083 "/** 0111 0101 0111 0000 0000 immm mvtipl #%1 */", 5084 op[0], op[1], op[2]); 5085 printf (" immm = 0x%x\n", immm); 5086 } 5087 SYNTAX("mvtipl #%1"); 5088 #line 1023 "rx-decode.opc" 5089 ID(mvtipl); SC(immm); 5090 5091 } 5092 break; 5093 default: UNSUPPORTED(); break; 5094 } 5095 break; 5096 case 0x90: 5097 GETBYTE (); 5098 switch (op[2] & 0xff) 5099 { 5100 case 0x1b: 5101 { 5102 /** 0111 0101 1001 0000 0001 1011 mvfdr */ 5103 if (trace) 5104 { 5105 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 5106 "/** 0111 0101 1001 0000 0001 1011 mvfdr */", 5107 op[0], op[1], op[2]); 5108 } 5109 SYNTAX("mvfdr"); 5110 #line 1229 "rx-decode.opc" 5111 ID(mvfdr); F_____; 5112 5113 } 5114 break; 5115 default: UNSUPPORTED(); break; 5116 } 5117 break; 5118 case 0xa0: 5119 GETBYTE (); 5120 switch (op[2] & 0x00) 5121 { 5122 case 0x00: 5123 { 5124 /** 0111 0101 1010 0000 rdst rnum dpushm.l %1-%2 */ 5125 #line 1223 "rx-decode.opc" 5126 int rdst AU = (op[2] >> 4) & 0x0f; 5127 #line 1223 "rx-decode.opc" 5128 int rnum AU = op[2] & 0x0f; 5129 if (trace) 5130 { 5131 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 5132 "/** 0111 0101 1010 0000 rdst rnum dpushm.l %1-%2 */", 5133 op[0], op[1], op[2]); 5134 printf (" rdst = 0x%x,", rdst); 5135 printf (" rnum = 0x%x\n", rnum); 5136 } 5137 SYNTAX("dpushm.l %1-%2"); 5138 #line 1223 "rx-decode.opc" 5139 ID(dpushm); SCR(rdst); S2CR(rdst + rnum); F_____; 5140 5141 } 5142 break; 5143 } 5144 break; 5145 case 0xa8: 5146 GETBYTE (); 5147 switch (op[2] & 0x00) 5148 { 5149 case 0x00: 5150 { 5151 /** 0111 0101 1010 1000 rdst rnum dpopm.l %1-%2 */ 5152 #line 1217 "rx-decode.opc" 5153 int rdst AU = (op[2] >> 4) & 0x0f; 5154 #line 1217 "rx-decode.opc" 5155 int rnum AU = op[2] & 0x0f; 5156 if (trace) 5157 { 5158 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 5159 "/** 0111 0101 1010 1000 rdst rnum dpopm.l %1-%2 */", 5160 op[0], op[1], op[2]); 5161 printf (" rdst = 0x%x,", rdst); 5162 printf (" rnum = 0x%x\n", rnum); 5163 } 5164 SYNTAX("dpopm.l %1-%2"); 5165 #line 1217 "rx-decode.opc" 5166 ID(dpopm); SCR(rdst); S2CR(rdst + rnum); F_____; 5167 5168 } 5169 break; 5170 } 5171 break; 5172 case 0xb0: 5173 GETBYTE (); 5174 switch (op[2] & 0x00) 5175 { 5176 case 0x00: 5177 { 5178 /** 0111 0101 1011 0000 rdst rnum dpushm.d %1-%2 */ 5179 #line 1220 "rx-decode.opc" 5180 int rdst AU = (op[2] >> 4) & 0x0f; 5181 #line 1220 "rx-decode.opc" 5182 int rnum AU = op[2] & 0x0f; 5183 if (trace) 5184 { 5185 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 5186 "/** 0111 0101 1011 0000 rdst rnum dpushm.d %1-%2 */", 5187 op[0], op[1], op[2]); 5188 printf (" rdst = 0x%x,", rdst); 5189 printf (" rnum = 0x%x\n", rnum); 5190 } 5191 SYNTAX("dpushm.d %1-%2"); 5192 #line 1220 "rx-decode.opc" 5193 ID(dpushm); SDR(rdst); S2DR(rdst + rnum); F_____; 5194 5195 } 5196 break; 5197 } 5198 break; 5199 case 0xb8: 5200 GETBYTE (); 5201 switch (op[2] & 0x00) 5202 { 5203 case 0x00: 5204 { 5205 /** 0111 0101 1011 1000 rdst rnum dpopm.d %1-%2 */ 5206 #line 1214 "rx-decode.opc" 5207 int rdst AU = (op[2] >> 4) & 0x0f; 5208 #line 1214 "rx-decode.opc" 5209 int rnum AU = op[2] & 0x0f; 5210 if (trace) 5211 { 5212 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 5213 "/** 0111 0101 1011 1000 rdst rnum dpopm.d %1-%2 */", 5214 op[0], op[1], op[2]); 5215 printf (" rdst = 0x%x,", rdst); 5216 printf (" rnum = 0x%x\n", rnum); 5217 } 5218 SYNTAX("dpopm.d %1-%2"); 5219 #line 1214 "rx-decode.opc" 5220 ID(dpopm); SDR(rdst); S2DR(rdst + rnum); F_____; 5221 5222 } 5223 break; 5224 } 5225 break; 5226 default: UNSUPPORTED(); break; 5227 } 5228 break; 5229 case 0x76: 5230 GETBYTE (); 5231 switch (op[1] & 0xff) 5232 { 5233 case 0x00: 5234 case 0x01: 5235 case 0x02: 5236 case 0x03: 5237 case 0x04: 5238 case 0x05: 5239 case 0x06: 5240 case 0x07: 5241 case 0x08: 5242 case 0x09: 5243 case 0x0a: 5244 case 0x0b: 5245 case 0x0c: 5246 case 0x0d: 5247 case 0x0e: 5248 case 0x0f: 5249 goto op_semantics_32; 5250 break; 5251 case 0x10: 5252 case 0x11: 5253 case 0x12: 5254 case 0x13: 5255 case 0x14: 5256 case 0x15: 5257 case 0x16: 5258 case 0x17: 5259 case 0x18: 5260 case 0x19: 5261 case 0x1a: 5262 case 0x1b: 5263 case 0x1c: 5264 case 0x1d: 5265 case 0x1e: 5266 case 0x1f: 5267 goto op_semantics_33; 5268 break; 5269 case 0x20: 5270 case 0x21: 5271 case 0x22: 5272 case 0x23: 5273 case 0x24: 5274 case 0x25: 5275 case 0x26: 5276 case 0x27: 5277 case 0x28: 5278 case 0x29: 5279 case 0x2a: 5280 case 0x2b: 5281 case 0x2c: 5282 case 0x2d: 5283 case 0x2e: 5284 case 0x2f: 5285 goto op_semantics_34; 5286 break; 5287 case 0x30: 5288 case 0x31: 5289 case 0x32: 5290 case 0x33: 5291 case 0x34: 5292 case 0x35: 5293 case 0x36: 5294 case 0x37: 5295 case 0x38: 5296 case 0x39: 5297 case 0x3a: 5298 case 0x3b: 5299 case 0x3c: 5300 case 0x3d: 5301 case 0x3e: 5302 case 0x3f: 5303 goto op_semantics_35; 5304 break; 5305 case 0x90: 5306 GETBYTE (); 5307 switch (op[2] & 0xff) 5308 { 5309 case 0x00: 5310 GETBYTE (); 5311 switch (op[3] & 0x00) 5312 { 5313 case 0x00: 5314 op_semantics_36: 5315 { 5316 /** 0111 0110 1001 0000 srcb 0000 rdst srca dadd %1, %2, %0 */ 5317 #line 1238 "rx-decode.opc" 5318 int srcb AU = (op[2] >> 4) & 0x0f; 5319 #line 1238 "rx-decode.opc" 5320 int rdst AU = (op[3] >> 4) & 0x0f; 5321 #line 1238 "rx-decode.opc" 5322 int srca AU = op[3] & 0x0f; 5323 if (trace) 5324 { 5325 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 5326 "/** 0111 0110 1001 0000 srcb 0000 rdst srca dadd %1, %2, %0 */", 5327 op[0], op[1], op[2], op[3]); 5328 printf (" srcb = 0x%x,", srcb); 5329 printf (" rdst = 0x%x,", rdst); 5330 printf (" srca = 0x%x\n", srca); 5331 } 5332 SYNTAX("dadd %1, %2, %0"); 5333 #line 1238 "rx-decode.opc" 5334 ID(dadd); DDR(rdst); SDR(srca); S2DR(srcb); F_____; 5335 5336 } 5337 break; 5338 } 5339 break; 5340 case 0x01: 5341 GETBYTE (); 5342 switch (op[3] & 0x00) 5343 { 5344 case 0x00: 5345 op_semantics_37: 5346 { 5347 /** 0111 0110 1001 0000 srcb 0001 rdst srca dsub %1, %2, %0 */ 5348 #line 1259 "rx-decode.opc" 5349 int srcb AU = (op[2] >> 4) & 0x0f; 5350 #line 1259 "rx-decode.opc" 5351 int rdst AU = (op[3] >> 4) & 0x0f; 5352 #line 1259 "rx-decode.opc" 5353 int srca AU = op[3] & 0x0f; 5354 if (trace) 5355 { 5356 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 5357 "/** 0111 0110 1001 0000 srcb 0001 rdst srca dsub %1, %2, %0 */", 5358 op[0], op[1], op[2], op[3]); 5359 printf (" srcb = 0x%x,", srcb); 5360 printf (" rdst = 0x%x,", rdst); 5361 printf (" srca = 0x%x\n", srca); 5362 } 5363 SYNTAX("dsub %1, %2, %0"); 5364 #line 1259 "rx-decode.opc" 5365 ID(dsub); DDR(rdst); SDR(srca); S2DR(srcb); F_____; 5366 5367 } 5368 break; 5369 } 5370 break; 5371 case 0x02: 5372 GETBYTE (); 5373 switch (op[3] & 0x00) 5374 { 5375 case 0x00: 5376 op_semantics_38: 5377 { 5378 /** 0111 0110 1001 0000 srcb 0010 rdst srca dmul %1, %2, %0 */ 5379 #line 1247 "rx-decode.opc" 5380 int srcb AU = (op[2] >> 4) & 0x0f; 5381 #line 1247 "rx-decode.opc" 5382 int rdst AU = (op[3] >> 4) & 0x0f; 5383 #line 1247 "rx-decode.opc" 5384 int srca AU = op[3] & 0x0f; 5385 if (trace) 5386 { 5387 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 5388 "/** 0111 0110 1001 0000 srcb 0010 rdst srca dmul %1, %2, %0 */", 5389 op[0], op[1], op[2], op[3]); 5390 printf (" srcb = 0x%x,", srcb); 5391 printf (" rdst = 0x%x,", rdst); 5392 printf (" srca = 0x%x\n", srca); 5393 } 5394 SYNTAX("dmul %1, %2, %0"); 5395 #line 1247 "rx-decode.opc" 5396 ID(dmul); DDR(rdst); SDR(srca); S2DR(srcb); F_____; 5397 5398 } 5399 break; 5400 } 5401 break; 5402 case 0x05: 5403 GETBYTE (); 5404 switch (op[3] & 0x00) 5405 { 5406 case 0x00: 5407 op_semantics_39: 5408 { 5409 /** 0111 0110 1001 0000 srcb 0101 rdst srca ddiv %1, %2, %0 */ 5410 #line 1244 "rx-decode.opc" 5411 int srcb AU = (op[2] >> 4) & 0x0f; 5412 #line 1244 "rx-decode.opc" 5413 int rdst AU = (op[3] >> 4) & 0x0f; 5414 #line 1244 "rx-decode.opc" 5415 int srca AU = op[3] & 0x0f; 5416 if (trace) 5417 { 5418 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 5419 "/** 0111 0110 1001 0000 srcb 0101 rdst srca ddiv %1, %2, %0 */", 5420 op[0], op[1], op[2], op[3]); 5421 printf (" srcb = 0x%x,", srcb); 5422 printf (" rdst = 0x%x,", rdst); 5423 printf (" srca = 0x%x\n", srca); 5424 } 5425 SYNTAX("ddiv %1, %2, %0"); 5426 #line 1244 "rx-decode.opc" 5427 ID(ddiv); DDR(rdst); SDR(srca); S2DR(srcb); F_____; 5428 5429 } 5430 break; 5431 } 5432 break; 5433 case 0x08: 5434 GETBYTE (); 5435 switch (op[3] & 0x00) 5436 { 5437 case 0x00: 5438 op_semantics_40: 5439 { 5440 /** 0111 0110 1001 0000 srcb 1000 cond srca dcmp%0 %1, %2 */ 5441 #line 1241 "rx-decode.opc" 5442 int srcb AU = (op[2] >> 4) & 0x0f; 5443 #line 1241 "rx-decode.opc" 5444 int cond AU = (op[3] >> 4) & 0x0f; 5445 #line 1241 "rx-decode.opc" 5446 int srca AU = op[3] & 0x0f; 5447 if (trace) 5448 { 5449 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 5450 "/** 0111 0110 1001 0000 srcb 1000 cond srca dcmp%0 %1, %2 */", 5451 op[0], op[1], op[2], op[3]); 5452 printf (" srcb = 0x%x,", srcb); 5453 printf (" cond = 0x%x,", cond); 5454 printf (" srca = 0x%x\n", srca); 5455 } 5456 SYNTAX("dcmp%0 %1, %2"); 5457 #line 1241 "rx-decode.opc" 5458 ID(dcmp); DCND(cond); SDR(srca); S2DR(srcb); F_____; 5459 5460 } 5461 break; 5462 } 5463 break; 5464 case 0x0c: 5465 GETBYTE (); 5466 switch (op[3] & 0x0f) 5467 { 5468 case 0x00: 5469 op_semantics_41: 5470 { 5471 /** 0111 0110 1001 0000 rsrc 1100 rdst 0000 dmov.d %1, %0 */ 5472 #line 1179 "rx-decode.opc" 5473 int rsrc AU = (op[2] >> 4) & 0x0f; 5474 #line 1179 "rx-decode.opc" 5475 int rdst AU = (op[3] >> 4) & 0x0f; 5476 if (trace) 5477 { 5478 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 5479 "/** 0111 0110 1001 0000 rsrc 1100 rdst 0000 dmov.d %1, %0 */", 5480 op[0], op[1], op[2], op[3]); 5481 printf (" rsrc = 0x%x,", rsrc); 5482 printf (" rdst = 0x%x\n", rdst); 5483 } 5484 SYNTAX("dmov.d %1, %0"); 5485 #line 1179 "rx-decode.opc" 5486 ID(dmov); DDR(rdst); SDR(rsrc); F_____; 5487 5488 } 5489 break; 5490 case 0x01: 5491 op_semantics_42: 5492 { 5493 /** 0111 0110 1001 0000 rsrc 1100 rdst 0001 dabs %1, %0 */ 5494 #line 1235 "rx-decode.opc" 5495 int rsrc AU = (op[2] >> 4) & 0x0f; 5496 #line 1235 "rx-decode.opc" 5497 int rdst AU = (op[3] >> 4) & 0x0f; 5498 if (trace) 5499 { 5500 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 5501 "/** 0111 0110 1001 0000 rsrc 1100 rdst 0001 dabs %1, %0 */", 5502 op[0], op[1], op[2], op[3]); 5503 printf (" rsrc = 0x%x,", rsrc); 5504 printf (" rdst = 0x%x\n", rdst); 5505 } 5506 SYNTAX("dabs %1, %0"); 5507 #line 1235 "rx-decode.opc" 5508 ID(dabs); DDR(rdst); SDR(rsrc); F_____; 5509 5510 } 5511 break; 5512 case 0x02: 5513 op_semantics_43: 5514 { 5515 /** 0111 0110 1001 0000 rsrc 1100 rdst 0010 dneg %1, %0 */ 5516 #line 1250 "rx-decode.opc" 5517 int rsrc AU = (op[2] >> 4) & 0x0f; 5518 #line 1250 "rx-decode.opc" 5519 int rdst AU = (op[3] >> 4) & 0x0f; 5520 if (trace) 5521 { 5522 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 5523 "/** 0111 0110 1001 0000 rsrc 1100 rdst 0010 dneg %1, %0 */", 5524 op[0], op[1], op[2], op[3]); 5525 printf (" rsrc = 0x%x,", rsrc); 5526 printf (" rdst = 0x%x\n", rdst); 5527 } 5528 SYNTAX("dneg %1, %0"); 5529 #line 1250 "rx-decode.opc" 5530 ID(dneg); DDR(rdst); SDR(rsrc); F_____; 5531 5532 } 5533 break; 5534 default: UNSUPPORTED(); break; 5535 } 5536 break; 5537 case 0x0d: 5538 GETBYTE (); 5539 switch (op[3] & 0x0f) 5540 { 5541 case 0x00: 5542 op_semantics_44: 5543 { 5544 /** 0111 0110 1001 0000 rsrc 1101 rdst 0000 dsqrt %1, %0 */ 5545 #line 1256 "rx-decode.opc" 5546 int rsrc AU = (op[2] >> 4) & 0x0f; 5547 #line 1256 "rx-decode.opc" 5548 int rdst AU = (op[3] >> 4) & 0x0f; 5549 if (trace) 5550 { 5551 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 5552 "/** 0111 0110 1001 0000 rsrc 1101 rdst 0000 dsqrt %1, %0 */", 5553 op[0], op[1], op[2], op[3]); 5554 printf (" rsrc = 0x%x,", rsrc); 5555 printf (" rdst = 0x%x\n", rdst); 5556 } 5557 SYNTAX("dsqrt %1, %0"); 5558 #line 1256 "rx-decode.opc" 5559 ID(dsqrt); DDR(rdst); SDR(rsrc); F_____; 5560 5561 } 5562 break; 5563 case 0x08: 5564 op_semantics_45: 5565 { 5566 /** 0111 0110 1001 0000 rsrc 1101 rdst 1000 dtoi %1, %0 */ 5567 #line 1265 "rx-decode.opc" 5568 int rsrc AU = (op[2] >> 4) & 0x0f; 5569 #line 1265 "rx-decode.opc" 5570 int rdst AU = (op[3] >> 4) & 0x0f; 5571 if (trace) 5572 { 5573 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 5574 "/** 0111 0110 1001 0000 rsrc 1101 rdst 1000 dtoi %1, %0 */", 5575 op[0], op[1], op[2], op[3]); 5576 printf (" rsrc = 0x%x,", rsrc); 5577 printf (" rdst = 0x%x\n", rdst); 5578 } 5579 SYNTAX("dtoi %1, %0"); 5580 #line 1265 "rx-decode.opc" 5581 ID(dtoi); DDR(rdst); SDR(rsrc); F_____; 5582 5583 } 5584 break; 5585 case 0x09: 5586 op_semantics_46: 5587 { 5588 /** 0111 0110 1001 0000 rsrc 1101 rdst 1001 dtou %1, %0 */ 5589 #line 1268 "rx-decode.opc" 5590 int rsrc AU = (op[2] >> 4) & 0x0f; 5591 #line 1268 "rx-decode.opc" 5592 int rdst AU = (op[3] >> 4) & 0x0f; 5593 if (trace) 5594 { 5595 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 5596 "/** 0111 0110 1001 0000 rsrc 1101 rdst 1001 dtou %1, %0 */", 5597 op[0], op[1], op[2], op[3]); 5598 printf (" rsrc = 0x%x,", rsrc); 5599 printf (" rdst = 0x%x\n", rdst); 5600 } 5601 SYNTAX("dtou %1, %0"); 5602 #line 1268 "rx-decode.opc" 5603 ID(dtou); DDR(rdst); SDR(rsrc); F_____; 5604 5605 } 5606 break; 5607 case 0x0c: 5608 op_semantics_47: 5609 { 5610 /** 0111 0110 1001 0000 rsrc 1101 rdst 1100 dtof %1, %0 */ 5611 #line 1262 "rx-decode.opc" 5612 int rsrc AU = (op[2] >> 4) & 0x0f; 5613 #line 1262 "rx-decode.opc" 5614 int rdst AU = (op[3] >> 4) & 0x0f; 5615 if (trace) 5616 { 5617 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 5618 "/** 0111 0110 1001 0000 rsrc 1101 rdst 1100 dtof %1, %0 */", 5619 op[0], op[1], op[2], op[3]); 5620 printf (" rsrc = 0x%x,", rsrc); 5621 printf (" rdst = 0x%x\n", rdst); 5622 } 5623 SYNTAX("dtof %1, %0"); 5624 #line 1262 "rx-decode.opc" 5625 ID(dtof); DDR(rdst); SDR(rsrc); F_____; 5626 5627 } 5628 break; 5629 case 0x0d: 5630 op_semantics_48: 5631 { 5632 /** 0111 0110 1001 0000 rsrc 1101 rdst 1101 dround %1, %0 */ 5633 #line 1253 "rx-decode.opc" 5634 int rsrc AU = (op[2] >> 4) & 0x0f; 5635 #line 1253 "rx-decode.opc" 5636 int rdst AU = (op[3] >> 4) & 0x0f; 5637 if (trace) 5638 { 5639 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 5640 "/** 0111 0110 1001 0000 rsrc 1101 rdst 1101 dround %1, %0 */", 5641 op[0], op[1], op[2], op[3]); 5642 printf (" rsrc = 0x%x,", rsrc); 5643 printf (" rdst = 0x%x\n", rdst); 5644 } 5645 SYNTAX("dround %1, %0"); 5646 #line 1253 "rx-decode.opc" 5647 ID(dround); DDR(rdst); SDR(rsrc); F_____; 5648 5649 } 5650 break; 5651 default: UNSUPPORTED(); break; 5652 } 5653 break; 5654 case 0x10: 5655 GETBYTE (); 5656 switch (op[3] & 0x00) 5657 { 5658 case 0x00: 5659 goto op_semantics_36; 5660 break; 5661 } 5662 break; 5663 case 0x11: 5664 GETBYTE (); 5665 switch (op[3] & 0x00) 5666 { 5667 case 0x00: 5668 goto op_semantics_37; 5669 break; 5670 } 5671 break; 5672 case 0x12: 5673 GETBYTE (); 5674 switch (op[3] & 0x00) 5675 { 5676 case 0x00: 5677 goto op_semantics_38; 5678 break; 5679 } 5680 break; 5681 case 0x15: 5682 GETBYTE (); 5683 switch (op[3] & 0x00) 5684 { 5685 case 0x00: 5686 goto op_semantics_39; 5687 break; 5688 } 5689 break; 5690 case 0x18: 5691 GETBYTE (); 5692 switch (op[3] & 0x00) 5693 { 5694 case 0x00: 5695 goto op_semantics_40; 5696 break; 5697 } 5698 break; 5699 case 0x1c: 5700 GETBYTE (); 5701 switch (op[3] & 0x0f) 5702 { 5703 case 0x00: 5704 goto op_semantics_41; 5705 break; 5706 case 0x01: 5707 goto op_semantics_42; 5708 break; 5709 case 0x02: 5710 goto op_semantics_43; 5711 break; 5712 default: UNSUPPORTED(); break; 5713 } 5714 break; 5715 case 0x1d: 5716 GETBYTE (); 5717 switch (op[3] & 0x0f) 5718 { 5719 case 0x00: 5720 goto op_semantics_44; 5721 break; 5722 case 0x08: 5723 goto op_semantics_45; 5724 break; 5725 case 0x09: 5726 goto op_semantics_46; 5727 break; 5728 case 0x0c: 5729 goto op_semantics_47; 5730 break; 5731 case 0x0d: 5732 goto op_semantics_48; 5733 break; 5734 default: UNSUPPORTED(); break; 5735 } 5736 break; 5737 case 0x20: 5738 GETBYTE (); 5739 switch (op[3] & 0x00) 5740 { 5741 case 0x00: 5742 goto op_semantics_36; 5743 break; 5744 } 5745 break; 5746 case 0x21: 5747 GETBYTE (); 5748 switch (op[3] & 0x00) 5749 { 5750 case 0x00: 5751 goto op_semantics_37; 5752 break; 5753 } 5754 break; 5755 case 0x22: 5756 GETBYTE (); 5757 switch (op[3] & 0x00) 5758 { 5759 case 0x00: 5760 goto op_semantics_38; 5761 break; 5762 } 5763 break; 5764 case 0x25: 5765 GETBYTE (); 5766 switch (op[3] & 0x00) 5767 { 5768 case 0x00: 5769 goto op_semantics_39; 5770 break; 5771 } 5772 break; 5773 case 0x28: 5774 GETBYTE (); 5775 switch (op[3] & 0x00) 5776 { 5777 case 0x00: 5778 goto op_semantics_40; 5779 break; 5780 } 5781 break; 5782 case 0x2c: 5783 GETBYTE (); 5784 switch (op[3] & 0x0f) 5785 { 5786 case 0x00: 5787 goto op_semantics_41; 5788 break; 5789 case 0x01: 5790 goto op_semantics_42; 5791 break; 5792 case 0x02: 5793 goto op_semantics_43; 5794 break; 5795 default: UNSUPPORTED(); break; 5796 } 5797 break; 5798 case 0x2d: 5799 GETBYTE (); 5800 switch (op[3] & 0x0f) 5801 { 5802 case 0x00: 5803 goto op_semantics_44; 5804 break; 5805 case 0x08: 5806 goto op_semantics_45; 5807 break; 5808 case 0x09: 5809 goto op_semantics_46; 5810 break; 5811 case 0x0c: 5812 goto op_semantics_47; 5813 break; 5814 case 0x0d: 5815 goto op_semantics_48; 5816 break; 5817 default: UNSUPPORTED(); break; 5818 } 5819 break; 5820 case 0x30: 5821 GETBYTE (); 5822 switch (op[3] & 0x00) 5823 { 5824 case 0x00: 5825 goto op_semantics_36; 5826 break; 5827 } 5828 break; 5829 case 0x31: 5830 GETBYTE (); 5831 switch (op[3] & 0x00) 5832 { 5833 case 0x00: 5834 goto op_semantics_37; 5835 break; 5836 } 5837 break; 5838 case 0x32: 5839 GETBYTE (); 5840 switch (op[3] & 0x00) 5841 { 5842 case 0x00: 5843 goto op_semantics_38; 5844 break; 5845 } 5846 break; 5847 case 0x35: 5848 GETBYTE (); 5849 switch (op[3] & 0x00) 5850 { 5851 case 0x00: 5852 goto op_semantics_39; 5853 break; 5854 } 5855 break; 5856 case 0x38: 5857 GETBYTE (); 5858 switch (op[3] & 0x00) 5859 { 5860 case 0x00: 5861 goto op_semantics_40; 5862 break; 5863 } 5864 break; 5865 case 0x3c: 5866 GETBYTE (); 5867 switch (op[3] & 0x0f) 5868 { 5869 case 0x00: 5870 goto op_semantics_41; 5871 break; 5872 case 0x01: 5873 goto op_semantics_42; 5874 break; 5875 case 0x02: 5876 goto op_semantics_43; 5877 break; 5878 default: UNSUPPORTED(); break; 5879 } 5880 break; 5881 case 0x3d: 5882 GETBYTE (); 5883 switch (op[3] & 0x0f) 5884 { 5885 case 0x00: 5886 goto op_semantics_44; 5887 break; 5888 case 0x08: 5889 goto op_semantics_45; 5890 break; 5891 case 0x09: 5892 goto op_semantics_46; 5893 break; 5894 case 0x0c: 5895 goto op_semantics_47; 5896 break; 5897 case 0x0d: 5898 goto op_semantics_48; 5899 break; 5900 default: UNSUPPORTED(); break; 5901 } 5902 break; 5903 case 0x40: 5904 GETBYTE (); 5905 switch (op[3] & 0x00) 5906 { 5907 case 0x00: 5908 goto op_semantics_36; 5909 break; 5910 } 5911 break; 5912 case 0x41: 5913 GETBYTE (); 5914 switch (op[3] & 0x00) 5915 { 5916 case 0x00: 5917 goto op_semantics_37; 5918 break; 5919 } 5920 break; 5921 case 0x42: 5922 GETBYTE (); 5923 switch (op[3] & 0x00) 5924 { 5925 case 0x00: 5926 goto op_semantics_38; 5927 break; 5928 } 5929 break; 5930 case 0x45: 5931 GETBYTE (); 5932 switch (op[3] & 0x00) 5933 { 5934 case 0x00: 5935 goto op_semantics_39; 5936 break; 5937 } 5938 break; 5939 case 0x48: 5940 GETBYTE (); 5941 switch (op[3] & 0x00) 5942 { 5943 case 0x00: 5944 goto op_semantics_40; 5945 break; 5946 } 5947 break; 5948 case 0x4c: 5949 GETBYTE (); 5950 switch (op[3] & 0x0f) 5951 { 5952 case 0x00: 5953 goto op_semantics_41; 5954 break; 5955 case 0x01: 5956 goto op_semantics_42; 5957 break; 5958 case 0x02: 5959 goto op_semantics_43; 5960 break; 5961 default: UNSUPPORTED(); break; 5962 } 5963 break; 5964 case 0x4d: 5965 GETBYTE (); 5966 switch (op[3] & 0x0f) 5967 { 5968 case 0x00: 5969 goto op_semantics_44; 5970 break; 5971 case 0x08: 5972 goto op_semantics_45; 5973 break; 5974 case 0x09: 5975 goto op_semantics_46; 5976 break; 5977 case 0x0c: 5978 goto op_semantics_47; 5979 break; 5980 case 0x0d: 5981 goto op_semantics_48; 5982 break; 5983 default: UNSUPPORTED(); break; 5984 } 5985 break; 5986 case 0x50: 5987 GETBYTE (); 5988 switch (op[3] & 0x00) 5989 { 5990 case 0x00: 5991 goto op_semantics_36; 5992 break; 5993 } 5994 break; 5995 case 0x51: 5996 GETBYTE (); 5997 switch (op[3] & 0x00) 5998 { 5999 case 0x00: 6000 goto op_semantics_37; 6001 break; 6002 } 6003 break; 6004 case 0x52: 6005 GETBYTE (); 6006 switch (op[3] & 0x00) 6007 { 6008 case 0x00: 6009 goto op_semantics_38; 6010 break; 6011 } 6012 break; 6013 case 0x55: 6014 GETBYTE (); 6015 switch (op[3] & 0x00) 6016 { 6017 case 0x00: 6018 goto op_semantics_39; 6019 break; 6020 } 6021 break; 6022 case 0x58: 6023 GETBYTE (); 6024 switch (op[3] & 0x00) 6025 { 6026 case 0x00: 6027 goto op_semantics_40; 6028 break; 6029 } 6030 break; 6031 case 0x5c: 6032 GETBYTE (); 6033 switch (op[3] & 0x0f) 6034 { 6035 case 0x00: 6036 goto op_semantics_41; 6037 break; 6038 case 0x01: 6039 goto op_semantics_42; 6040 break; 6041 case 0x02: 6042 goto op_semantics_43; 6043 break; 6044 default: UNSUPPORTED(); break; 6045 } 6046 break; 6047 case 0x5d: 6048 GETBYTE (); 6049 switch (op[3] & 0x0f) 6050 { 6051 case 0x00: 6052 goto op_semantics_44; 6053 break; 6054 case 0x08: 6055 goto op_semantics_45; 6056 break; 6057 case 0x09: 6058 goto op_semantics_46; 6059 break; 6060 case 0x0c: 6061 goto op_semantics_47; 6062 break; 6063 case 0x0d: 6064 goto op_semantics_48; 6065 break; 6066 default: UNSUPPORTED(); break; 6067 } 6068 break; 6069 case 0x60: 6070 GETBYTE (); 6071 switch (op[3] & 0x00) 6072 { 6073 case 0x00: 6074 goto op_semantics_36; 6075 break; 6076 } 6077 break; 6078 case 0x61: 6079 GETBYTE (); 6080 switch (op[3] & 0x00) 6081 { 6082 case 0x00: 6083 goto op_semantics_37; 6084 break; 6085 } 6086 break; 6087 case 0x62: 6088 GETBYTE (); 6089 switch (op[3] & 0x00) 6090 { 6091 case 0x00: 6092 goto op_semantics_38; 6093 break; 6094 } 6095 break; 6096 case 0x65: 6097 GETBYTE (); 6098 switch (op[3] & 0x00) 6099 { 6100 case 0x00: 6101 goto op_semantics_39; 6102 break; 6103 } 6104 break; 6105 case 0x68: 6106 GETBYTE (); 6107 switch (op[3] & 0x00) 6108 { 6109 case 0x00: 6110 goto op_semantics_40; 6111 break; 6112 } 6113 break; 6114 case 0x6c: 6115 GETBYTE (); 6116 switch (op[3] & 0x0f) 6117 { 6118 case 0x00: 6119 goto op_semantics_41; 6120 break; 6121 case 0x01: 6122 goto op_semantics_42; 6123 break; 6124 case 0x02: 6125 goto op_semantics_43; 6126 break; 6127 default: UNSUPPORTED(); break; 6128 } 6129 break; 6130 case 0x6d: 6131 GETBYTE (); 6132 switch (op[3] & 0x0f) 6133 { 6134 case 0x00: 6135 goto op_semantics_44; 6136 break; 6137 case 0x08: 6138 goto op_semantics_45; 6139 break; 6140 case 0x09: 6141 goto op_semantics_46; 6142 break; 6143 case 0x0c: 6144 goto op_semantics_47; 6145 break; 6146 case 0x0d: 6147 goto op_semantics_48; 6148 break; 6149 default: UNSUPPORTED(); break; 6150 } 6151 break; 6152 case 0x70: 6153 GETBYTE (); 6154 switch (op[3] & 0x00) 6155 { 6156 case 0x00: 6157 goto op_semantics_36; 6158 break; 6159 } 6160 break; 6161 case 0x71: 6162 GETBYTE (); 6163 switch (op[3] & 0x00) 6164 { 6165 case 0x00: 6166 goto op_semantics_37; 6167 break; 6168 } 6169 break; 6170 case 0x72: 6171 GETBYTE (); 6172 switch (op[3] & 0x00) 6173 { 6174 case 0x00: 6175 goto op_semantics_38; 6176 break; 6177 } 6178 break; 6179 case 0x75: 6180 GETBYTE (); 6181 switch (op[3] & 0x00) 6182 { 6183 case 0x00: 6184 goto op_semantics_39; 6185 break; 6186 } 6187 break; 6188 case 0x78: 6189 GETBYTE (); 6190 switch (op[3] & 0x00) 6191 { 6192 case 0x00: 6193 goto op_semantics_40; 6194 break; 6195 } 6196 break; 6197 case 0x7c: 6198 GETBYTE (); 6199 switch (op[3] & 0x0f) 6200 { 6201 case 0x00: 6202 goto op_semantics_41; 6203 break; 6204 case 0x01: 6205 goto op_semantics_42; 6206 break; 6207 case 0x02: 6208 goto op_semantics_43; 6209 break; 6210 default: UNSUPPORTED(); break; 6211 } 6212 break; 6213 case 0x7d: 6214 GETBYTE (); 6215 switch (op[3] & 0x0f) 6216 { 6217 case 0x00: 6218 goto op_semantics_44; 6219 break; 6220 case 0x08: 6221 goto op_semantics_45; 6222 break; 6223 case 0x09: 6224 goto op_semantics_46; 6225 break; 6226 case 0x0c: 6227 goto op_semantics_47; 6228 break; 6229 case 0x0d: 6230 goto op_semantics_48; 6231 break; 6232 default: UNSUPPORTED(); break; 6233 } 6234 break; 6235 case 0x80: 6236 GETBYTE (); 6237 switch (op[3] & 0x00) 6238 { 6239 case 0x00: 6240 goto op_semantics_36; 6241 break; 6242 } 6243 break; 6244 case 0x81: 6245 GETBYTE (); 6246 switch (op[3] & 0x00) 6247 { 6248 case 0x00: 6249 goto op_semantics_37; 6250 break; 6251 } 6252 break; 6253 case 0x82: 6254 GETBYTE (); 6255 switch (op[3] & 0x00) 6256 { 6257 case 0x00: 6258 goto op_semantics_38; 6259 break; 6260 } 6261 break; 6262 case 0x85: 6263 GETBYTE (); 6264 switch (op[3] & 0x00) 6265 { 6266 case 0x00: 6267 goto op_semantics_39; 6268 break; 6269 } 6270 break; 6271 case 0x88: 6272 GETBYTE (); 6273 switch (op[3] & 0x00) 6274 { 6275 case 0x00: 6276 goto op_semantics_40; 6277 break; 6278 } 6279 break; 6280 case 0x8c: 6281 GETBYTE (); 6282 switch (op[3] & 0x0f) 6283 { 6284 case 0x00: 6285 goto op_semantics_41; 6286 break; 6287 case 0x01: 6288 goto op_semantics_42; 6289 break; 6290 case 0x02: 6291 goto op_semantics_43; 6292 break; 6293 default: UNSUPPORTED(); break; 6294 } 6295 break; 6296 case 0x8d: 6297 GETBYTE (); 6298 switch (op[3] & 0x0f) 6299 { 6300 case 0x00: 6301 goto op_semantics_44; 6302 break; 6303 case 0x08: 6304 goto op_semantics_45; 6305 break; 6306 case 0x09: 6307 goto op_semantics_46; 6308 break; 6309 case 0x0c: 6310 goto op_semantics_47; 6311 break; 6312 case 0x0d: 6313 goto op_semantics_48; 6314 break; 6315 default: UNSUPPORTED(); break; 6316 } 6317 break; 6318 case 0x90: 6319 GETBYTE (); 6320 switch (op[3] & 0x00) 6321 { 6322 case 0x00: 6323 goto op_semantics_36; 6324 break; 6325 } 6326 break; 6327 case 0x91: 6328 GETBYTE (); 6329 switch (op[3] & 0x00) 6330 { 6331 case 0x00: 6332 goto op_semantics_37; 6333 break; 6334 } 6335 break; 6336 case 0x92: 6337 GETBYTE (); 6338 switch (op[3] & 0x00) 6339 { 6340 case 0x00: 6341 goto op_semantics_38; 6342 break; 6343 } 6344 break; 6345 case 0x95: 6346 GETBYTE (); 6347 switch (op[3] & 0x00) 6348 { 6349 case 0x00: 6350 goto op_semantics_39; 6351 break; 6352 } 6353 break; 6354 case 0x98: 6355 GETBYTE (); 6356 switch (op[3] & 0x00) 6357 { 6358 case 0x00: 6359 goto op_semantics_40; 6360 break; 6361 } 6362 break; 6363 case 0x9c: 6364 GETBYTE (); 6365 switch (op[3] & 0x0f) 6366 { 6367 case 0x00: 6368 goto op_semantics_41; 6369 break; 6370 case 0x01: 6371 goto op_semantics_42; 6372 break; 6373 case 0x02: 6374 goto op_semantics_43; 6375 break; 6376 default: UNSUPPORTED(); break; 6377 } 6378 break; 6379 case 0x9d: 6380 GETBYTE (); 6381 switch (op[3] & 0x0f) 6382 { 6383 case 0x00: 6384 goto op_semantics_44; 6385 break; 6386 case 0x08: 6387 goto op_semantics_45; 6388 break; 6389 case 0x09: 6390 goto op_semantics_46; 6391 break; 6392 case 0x0c: 6393 goto op_semantics_47; 6394 break; 6395 case 0x0d: 6396 goto op_semantics_48; 6397 break; 6398 default: UNSUPPORTED(); break; 6399 } 6400 break; 6401 case 0xa0: 6402 GETBYTE (); 6403 switch (op[3] & 0x00) 6404 { 6405 case 0x00: 6406 goto op_semantics_36; 6407 break; 6408 } 6409 break; 6410 case 0xa1: 6411 GETBYTE (); 6412 switch (op[3] & 0x00) 6413 { 6414 case 0x00: 6415 goto op_semantics_37; 6416 break; 6417 } 6418 break; 6419 case 0xa2: 6420 GETBYTE (); 6421 switch (op[3] & 0x00) 6422 { 6423 case 0x00: 6424 goto op_semantics_38; 6425 break; 6426 } 6427 break; 6428 case 0xa5: 6429 GETBYTE (); 6430 switch (op[3] & 0x00) 6431 { 6432 case 0x00: 6433 goto op_semantics_39; 6434 break; 6435 } 6436 break; 6437 case 0xa8: 6438 GETBYTE (); 6439 switch (op[3] & 0x00) 6440 { 6441 case 0x00: 6442 goto op_semantics_40; 6443 break; 6444 } 6445 break; 6446 case 0xac: 6447 GETBYTE (); 6448 switch (op[3] & 0x0f) 6449 { 6450 case 0x00: 6451 goto op_semantics_41; 6452 break; 6453 case 0x01: 6454 goto op_semantics_42; 6455 break; 6456 case 0x02: 6457 goto op_semantics_43; 6458 break; 6459 default: UNSUPPORTED(); break; 6460 } 6461 break; 6462 case 0xad: 6463 GETBYTE (); 6464 switch (op[3] & 0x0f) 6465 { 6466 case 0x00: 6467 goto op_semantics_44; 6468 break; 6469 case 0x08: 6470 goto op_semantics_45; 6471 break; 6472 case 0x09: 6473 goto op_semantics_46; 6474 break; 6475 case 0x0c: 6476 goto op_semantics_47; 6477 break; 6478 case 0x0d: 6479 goto op_semantics_48; 6480 break; 6481 default: UNSUPPORTED(); break; 6482 } 6483 break; 6484 case 0xb0: 6485 GETBYTE (); 6486 switch (op[3] & 0x00) 6487 { 6488 case 0x00: 6489 goto op_semantics_36; 6490 break; 6491 } 6492 break; 6493 case 0xb1: 6494 GETBYTE (); 6495 switch (op[3] & 0x00) 6496 { 6497 case 0x00: 6498 goto op_semantics_37; 6499 break; 6500 } 6501 break; 6502 case 0xb2: 6503 GETBYTE (); 6504 switch (op[3] & 0x00) 6505 { 6506 case 0x00: 6507 goto op_semantics_38; 6508 break; 6509 } 6510 break; 6511 case 0xb5: 6512 GETBYTE (); 6513 switch (op[3] & 0x00) 6514 { 6515 case 0x00: 6516 goto op_semantics_39; 6517 break; 6518 } 6519 break; 6520 case 0xb8: 6521 GETBYTE (); 6522 switch (op[3] & 0x00) 6523 { 6524 case 0x00: 6525 goto op_semantics_40; 6526 break; 6527 } 6528 break; 6529 case 0xbc: 6530 GETBYTE (); 6531 switch (op[3] & 0x0f) 6532 { 6533 case 0x00: 6534 goto op_semantics_41; 6535 break; 6536 case 0x01: 6537 goto op_semantics_42; 6538 break; 6539 case 0x02: 6540 goto op_semantics_43; 6541 break; 6542 default: UNSUPPORTED(); break; 6543 } 6544 break; 6545 case 0xbd: 6546 GETBYTE (); 6547 switch (op[3] & 0x0f) 6548 { 6549 case 0x00: 6550 goto op_semantics_44; 6551 break; 6552 case 0x08: 6553 goto op_semantics_45; 6554 break; 6555 case 0x09: 6556 goto op_semantics_46; 6557 break; 6558 case 0x0c: 6559 goto op_semantics_47; 6560 break; 6561 case 0x0d: 6562 goto op_semantics_48; 6563 break; 6564 default: UNSUPPORTED(); break; 6565 } 6566 break; 6567 case 0xc0: 6568 GETBYTE (); 6569 switch (op[3] & 0x00) 6570 { 6571 case 0x00: 6572 goto op_semantics_36; 6573 break; 6574 } 6575 break; 6576 case 0xc1: 6577 GETBYTE (); 6578 switch (op[3] & 0x00) 6579 { 6580 case 0x00: 6581 goto op_semantics_37; 6582 break; 6583 } 6584 break; 6585 case 0xc2: 6586 GETBYTE (); 6587 switch (op[3] & 0x00) 6588 { 6589 case 0x00: 6590 goto op_semantics_38; 6591 break; 6592 } 6593 break; 6594 case 0xc5: 6595 GETBYTE (); 6596 switch (op[3] & 0x00) 6597 { 6598 case 0x00: 6599 goto op_semantics_39; 6600 break; 6601 } 6602 break; 6603 case 0xc8: 6604 GETBYTE (); 6605 switch (op[3] & 0x00) 6606 { 6607 case 0x00: 6608 goto op_semantics_40; 6609 break; 6610 } 6611 break; 6612 case 0xcc: 6613 GETBYTE (); 6614 switch (op[3] & 0x0f) 6615 { 6616 case 0x00: 6617 goto op_semantics_41; 6618 break; 6619 case 0x01: 6620 goto op_semantics_42; 6621 break; 6622 case 0x02: 6623 goto op_semantics_43; 6624 break; 6625 default: UNSUPPORTED(); break; 6626 } 6627 break; 6628 case 0xcd: 6629 GETBYTE (); 6630 switch (op[3] & 0x0f) 6631 { 6632 case 0x00: 6633 goto op_semantics_44; 6634 break; 6635 case 0x08: 6636 goto op_semantics_45; 6637 break; 6638 case 0x09: 6639 goto op_semantics_46; 6640 break; 6641 case 0x0c: 6642 goto op_semantics_47; 6643 break; 6644 case 0x0d: 6645 goto op_semantics_48; 6646 break; 6647 default: UNSUPPORTED(); break; 6648 } 6649 break; 6650 case 0xd0: 6651 GETBYTE (); 6652 switch (op[3] & 0x00) 6653 { 6654 case 0x00: 6655 goto op_semantics_36; 6656 break; 6657 } 6658 break; 6659 case 0xd1: 6660 GETBYTE (); 6661 switch (op[3] & 0x00) 6662 { 6663 case 0x00: 6664 goto op_semantics_37; 6665 break; 6666 } 6667 break; 6668 case 0xd2: 6669 GETBYTE (); 6670 switch (op[3] & 0x00) 6671 { 6672 case 0x00: 6673 goto op_semantics_38; 6674 break; 6675 } 6676 break; 6677 case 0xd5: 6678 GETBYTE (); 6679 switch (op[3] & 0x00) 6680 { 6681 case 0x00: 6682 goto op_semantics_39; 6683 break; 6684 } 6685 break; 6686 case 0xd8: 6687 GETBYTE (); 6688 switch (op[3] & 0x00) 6689 { 6690 case 0x00: 6691 goto op_semantics_40; 6692 break; 6693 } 6694 break; 6695 case 0xdc: 6696 GETBYTE (); 6697 switch (op[3] & 0x0f) 6698 { 6699 case 0x00: 6700 goto op_semantics_41; 6701 break; 6702 case 0x01: 6703 goto op_semantics_42; 6704 break; 6705 case 0x02: 6706 goto op_semantics_43; 6707 break; 6708 default: UNSUPPORTED(); break; 6709 } 6710 break; 6711 case 0xdd: 6712 GETBYTE (); 6713 switch (op[3] & 0x0f) 6714 { 6715 case 0x00: 6716 goto op_semantics_44; 6717 break; 6718 case 0x08: 6719 goto op_semantics_45; 6720 break; 6721 case 0x09: 6722 goto op_semantics_46; 6723 break; 6724 case 0x0c: 6725 goto op_semantics_47; 6726 break; 6727 case 0x0d: 6728 goto op_semantics_48; 6729 break; 6730 default: UNSUPPORTED(); break; 6731 } 6732 break; 6733 case 0xe0: 6734 GETBYTE (); 6735 switch (op[3] & 0x00) 6736 { 6737 case 0x00: 6738 goto op_semantics_36; 6739 break; 6740 } 6741 break; 6742 case 0xe1: 6743 GETBYTE (); 6744 switch (op[3] & 0x00) 6745 { 6746 case 0x00: 6747 goto op_semantics_37; 6748 break; 6749 } 6750 break; 6751 case 0xe2: 6752 GETBYTE (); 6753 switch (op[3] & 0x00) 6754 { 6755 case 0x00: 6756 goto op_semantics_38; 6757 break; 6758 } 6759 break; 6760 case 0xe5: 6761 GETBYTE (); 6762 switch (op[3] & 0x00) 6763 { 6764 case 0x00: 6765 goto op_semantics_39; 6766 break; 6767 } 6768 break; 6769 case 0xe8: 6770 GETBYTE (); 6771 switch (op[3] & 0x00) 6772 { 6773 case 0x00: 6774 goto op_semantics_40; 6775 break; 6776 } 6777 break; 6778 case 0xec: 6779 GETBYTE (); 6780 switch (op[3] & 0x0f) 6781 { 6782 case 0x00: 6783 goto op_semantics_41; 6784 break; 6785 case 0x01: 6786 goto op_semantics_42; 6787 break; 6788 case 0x02: 6789 goto op_semantics_43; 6790 break; 6791 default: UNSUPPORTED(); break; 6792 } 6793 break; 6794 case 0xed: 6795 GETBYTE (); 6796 switch (op[3] & 0x0f) 6797 { 6798 case 0x00: 6799 goto op_semantics_44; 6800 break; 6801 case 0x08: 6802 goto op_semantics_45; 6803 break; 6804 case 0x09: 6805 goto op_semantics_46; 6806 break; 6807 case 0x0c: 6808 goto op_semantics_47; 6809 break; 6810 case 0x0d: 6811 goto op_semantics_48; 6812 break; 6813 default: UNSUPPORTED(); break; 6814 } 6815 break; 6816 case 0xf0: 6817 GETBYTE (); 6818 switch (op[3] & 0x00) 6819 { 6820 case 0x00: 6821 goto op_semantics_36; 6822 break; 6823 } 6824 break; 6825 case 0xf1: 6826 GETBYTE (); 6827 switch (op[3] & 0x00) 6828 { 6829 case 0x00: 6830 goto op_semantics_37; 6831 break; 6832 } 6833 break; 6834 case 0xf2: 6835 GETBYTE (); 6836 switch (op[3] & 0x00) 6837 { 6838 case 0x00: 6839 goto op_semantics_38; 6840 break; 6841 } 6842 break; 6843 case 0xf5: 6844 GETBYTE (); 6845 switch (op[3] & 0x00) 6846 { 6847 case 0x00: 6848 goto op_semantics_39; 6849 break; 6850 } 6851 break; 6852 case 0xf8: 6853 GETBYTE (); 6854 switch (op[3] & 0x00) 6855 { 6856 case 0x00: 6857 goto op_semantics_40; 6858 break; 6859 } 6860 break; 6861 case 0xfc: 6862 GETBYTE (); 6863 switch (op[3] & 0x0f) 6864 { 6865 case 0x00: 6866 goto op_semantics_41; 6867 break; 6868 case 0x01: 6869 goto op_semantics_42; 6870 break; 6871 case 0x02: 6872 goto op_semantics_43; 6873 break; 6874 default: UNSUPPORTED(); break; 6875 } 6876 break; 6877 case 0xfd: 6878 GETBYTE (); 6879 switch (op[3] & 0x0f) 6880 { 6881 case 0x00: 6882 goto op_semantics_44; 6883 break; 6884 case 0x08: 6885 goto op_semantics_45; 6886 break; 6887 case 0x09: 6888 goto op_semantics_46; 6889 break; 6890 case 0x0c: 6891 goto op_semantics_47; 6892 break; 6893 case 0x0d: 6894 goto op_semantics_48; 6895 break; 6896 default: UNSUPPORTED(); break; 6897 } 6898 break; 6899 default: UNSUPPORTED(); break; 6900 } 6901 break; 6902 default: UNSUPPORTED(); break; 6903 } 6904 break; 6905 case 0x77: 6906 GETBYTE (); 6907 switch (op[1] & 0xf0) 6908 { 6909 case 0x00: 6910 goto op_semantics_32; 6911 break; 6912 case 0x10: 6913 goto op_semantics_33; 6914 break; 6915 case 0x20: 6916 goto op_semantics_34; 6917 break; 6918 case 0x30: 6919 goto op_semantics_35; 6920 break; 6921 default: UNSUPPORTED(); break; 6922 } 6923 break; 6924 case 0x78: 6925 GETBYTE (); 6926 switch (op[1] & 0x00) 6927 { 6928 case 0x00: 6929 op_semantics_49: 6930 { 6931 /** 0111 100b ittt rdst bset #%1, %0 */ 6932 #line 968 "rx-decode.opc" 6933 int b AU = op[0] & 0x01; 6934 #line 968 "rx-decode.opc" 6935 int ittt AU = (op[1] >> 4) & 0x0f; 6936 #line 968 "rx-decode.opc" 6937 int rdst AU = op[1] & 0x0f; 6938 if (trace) 6939 { 6940 printf ("\033[33m%s\033[0m %02x %02x\n", 6941 "/** 0111 100b ittt rdst bset #%1, %0 */", 6942 op[0], op[1]); 6943 printf (" b = 0x%x,", b); 6944 printf (" ittt = 0x%x,", ittt); 6945 printf (" rdst = 0x%x\n", rdst); 6946 } 6947 SYNTAX("bset #%1, %0"); 6948 #line 968 "rx-decode.opc" 6949 ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____; 6950 6951 6952 } 6953 break; 6954 } 6955 break; 6956 case 0x79: 6957 GETBYTE (); 6958 switch (op[1] & 0x00) 6959 { 6960 case 0x00: 6961 goto op_semantics_49; 6962 break; 6963 } 6964 break; 6965 case 0x7a: 6966 GETBYTE (); 6967 switch (op[1] & 0x00) 6968 { 6969 case 0x00: 6970 op_semantics_50: 6971 { 6972 /** 0111 101b ittt rdst bclr #%1, %0 */ 6973 #line 980 "rx-decode.opc" 6974 int b AU = op[0] & 0x01; 6975 #line 980 "rx-decode.opc" 6976 int ittt AU = (op[1] >> 4) & 0x0f; 6977 #line 980 "rx-decode.opc" 6978 int rdst AU = op[1] & 0x0f; 6979 if (trace) 6980 { 6981 printf ("\033[33m%s\033[0m %02x %02x\n", 6982 "/** 0111 101b ittt rdst bclr #%1, %0 */", 6983 op[0], op[1]); 6984 printf (" b = 0x%x,", b); 6985 printf (" ittt = 0x%x,", ittt); 6986 printf (" rdst = 0x%x\n", rdst); 6987 } 6988 SYNTAX("bclr #%1, %0"); 6989 #line 980 "rx-decode.opc" 6990 ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____; 6991 6992 6993 } 6994 break; 6995 } 6996 break; 6997 case 0x7b: 6998 GETBYTE (); 6999 switch (op[1] & 0x00) 7000 { 7001 case 0x00: 7002 goto op_semantics_50; 7003 break; 7004 } 7005 break; 7006 case 0x7c: 7007 GETBYTE (); 7008 switch (op[1] & 0x00) 7009 { 7010 case 0x00: 7011 op_semantics_51: 7012 { 7013 /** 0111 110b ittt rdst btst #%2, %1 */ 7014 #line 992 "rx-decode.opc" 7015 int b AU = op[0] & 0x01; 7016 #line 992 "rx-decode.opc" 7017 int ittt AU = (op[1] >> 4) & 0x0f; 7018 #line 992 "rx-decode.opc" 7019 int rdst AU = op[1] & 0x0f; 7020 if (trace) 7021 { 7022 printf ("\033[33m%s\033[0m %02x %02x\n", 7023 "/** 0111 110b ittt rdst btst #%2, %1 */", 7024 op[0], op[1]); 7025 printf (" b = 0x%x,", b); 7026 printf (" ittt = 0x%x,", ittt); 7027 printf (" rdst = 0x%x\n", rdst); 7028 } 7029 SYNTAX("btst #%2, %1"); 7030 #line 992 "rx-decode.opc" 7031 ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F___ZC; 7032 7033 7034 } 7035 break; 7036 } 7037 break; 7038 case 0x7d: 7039 GETBYTE (); 7040 switch (op[1] & 0x00) 7041 { 7042 case 0x00: 7043 goto op_semantics_51; 7044 break; 7045 } 7046 break; 7047 case 0x7e: 7048 GETBYTE (); 7049 switch (op[1] & 0xf0) 7050 { 7051 case 0x00: 7052 { 7053 /** 0111 1110 0000 rdst not %0 */ 7054 #line 483 "rx-decode.opc" 7055 int rdst AU = op[1] & 0x0f; 7056 if (trace) 7057 { 7058 printf ("\033[33m%s\033[0m %02x %02x\n", 7059 "/** 0111 1110 0000 rdst not %0 */", 7060 op[0], op[1]); 7061 printf (" rdst = 0x%x\n", rdst); 7062 } 7063 SYNTAX("not %0"); 7064 #line 483 "rx-decode.opc" 7065 ID(xor); DR(rdst); SR(rdst); S2C(~0); F__SZ_; 7066 7067 } 7068 break; 7069 case 0x10: 7070 { 7071 /** 0111 1110 0001 rdst neg %0 */ 7072 #line 504 "rx-decode.opc" 7073 int rdst AU = op[1] & 0x0f; 7074 if (trace) 7075 { 7076 printf ("\033[33m%s\033[0m %02x %02x\n", 7077 "/** 0111 1110 0001 rdst neg %0 */", 7078 op[0], op[1]); 7079 printf (" rdst = 0x%x\n", rdst); 7080 } 7081 SYNTAX("neg %0"); 7082 #line 504 "rx-decode.opc" 7083 ID(sub); DR(rdst); SC(0); S2R(rdst); F_OSZC; 7084 7085 } 7086 break; 7087 case 0x20: 7088 { 7089 /** 0111 1110 0010 rdst abs %0 */ 7090 #line 586 "rx-decode.opc" 7091 int rdst AU = op[1] & 0x0f; 7092 if (trace) 7093 { 7094 printf ("\033[33m%s\033[0m %02x %02x\n", 7095 "/** 0111 1110 0010 rdst abs %0 */", 7096 op[0], op[1]); 7097 printf (" rdst = 0x%x\n", rdst); 7098 } 7099 SYNTAX("abs %0"); 7100 #line 586 "rx-decode.opc" 7101 ID(abs); DR(rdst); SR(rdst); F_OSZ_; 7102 7103 } 7104 break; 7105 case 0x30: 7106 { 7107 /** 0111 1110 0011 rdst sat %0 */ 7108 #line 906 "rx-decode.opc" 7109 int rdst AU = op[1] & 0x0f; 7110 if (trace) 7111 { 7112 printf ("\033[33m%s\033[0m %02x %02x\n", 7113 "/** 0111 1110 0011 rdst sat %0 */", 7114 op[0], op[1]); 7115 printf (" rdst = 0x%x\n", rdst); 7116 } 7117 SYNTAX("sat %0"); 7118 #line 906 "rx-decode.opc" 7119 ID(sat); DR (rdst); 7120 7121 } 7122 break; 7123 case 0x40: 7124 { 7125 /** 0111 1110 0100 rdst rorc %0 */ 7126 #line 766 "rx-decode.opc" 7127 int rdst AU = op[1] & 0x0f; 7128 if (trace) 7129 { 7130 printf ("\033[33m%s\033[0m %02x %02x\n", 7131 "/** 0111 1110 0100 rdst rorc %0 */", 7132 op[0], op[1]); 7133 printf (" rdst = 0x%x\n", rdst); 7134 } 7135 SYNTAX("rorc %0"); 7136 #line 766 "rx-decode.opc" 7137 ID(rorc); DR(rdst); F__SZC; 7138 7139 } 7140 break; 7141 case 0x50: 7142 { 7143 /** 0111 1110 0101 rdst rolc %0 */ 7144 #line 763 "rx-decode.opc" 7145 int rdst AU = op[1] & 0x0f; 7146 if (trace) 7147 { 7148 printf ("\033[33m%s\033[0m %02x %02x\n", 7149 "/** 0111 1110 0101 rdst rolc %0 */", 7150 op[0], op[1]); 7151 printf (" rdst = 0x%x\n", rdst); 7152 } 7153 SYNTAX("rolc %0"); 7154 #line 763 "rx-decode.opc" 7155 ID(rolc); DR(rdst); F__SZC; 7156 7157 } 7158 break; 7159 case 0x80: 7160 case 0x90: 7161 case 0xa0: 7162 { 7163 /** 0111 1110 10sz rsrc push%s %1 */ 7164 #line 399 "rx-decode.opc" 7165 int sz AU = (op[1] >> 4) & 0x03; 7166 #line 399 "rx-decode.opc" 7167 int rsrc AU = op[1] & 0x0f; 7168 if (trace) 7169 { 7170 printf ("\033[33m%s\033[0m %02x %02x\n", 7171 "/** 0111 1110 10sz rsrc push%s %1 */", 7172 op[0], op[1]); 7173 printf (" sz = 0x%x,", sz); 7174 printf (" rsrc = 0x%x\n", rsrc); 7175 } 7176 SYNTAX("push%s %1"); 7177 #line 399 "rx-decode.opc" 7178 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F_____; 7179 7180 } 7181 break; 7182 case 0xb0: 7183 { 7184 /** 0111 1110 1011 rdst pop %0 */ 7185 #line 396 "rx-decode.opc" 7186 int rdst AU = op[1] & 0x0f; 7187 if (trace) 7188 { 7189 printf ("\033[33m%s\033[0m %02x %02x\n", 7190 "/** 0111 1110 1011 rdst pop %0 */", 7191 op[0], op[1]); 7192 printf (" rdst = 0x%x\n", rdst); 7193 } 7194 SYNTAX("pop %0"); 7195 #line 396 "rx-decode.opc" 7196 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F_____; 7197 7198 } 7199 break; 7200 case 0xc0: 7201 case 0xd0: 7202 { 7203 /** 0111 1110 110 crsrc pushc %1 */ 7204 #line 1029 "rx-decode.opc" 7205 int crsrc AU = op[1] & 0x1f; 7206 if (trace) 7207 { 7208 printf ("\033[33m%s\033[0m %02x %02x\n", 7209 "/** 0111 1110 110 crsrc pushc %1 */", 7210 op[0], op[1]); 7211 printf (" crsrc = 0x%x\n", crsrc); 7212 } 7213 SYNTAX("pushc %1"); 7214 #line 1029 "rx-decode.opc" 7215 ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16); 7216 7217 } 7218 break; 7219 case 0xe0: 7220 case 0xf0: 7221 { 7222 /** 0111 1110 111 crdst popc %0 */ 7223 #line 1026 "rx-decode.opc" 7224 int crdst AU = op[1] & 0x1f; 7225 if (trace) 7226 { 7227 printf ("\033[33m%s\033[0m %02x %02x\n", 7228 "/** 0111 1110 111 crdst popc %0 */", 7229 op[0], op[1]); 7230 printf (" crdst = 0x%x\n", crdst); 7231 } 7232 SYNTAX("popc %0"); 7233 #line 1026 "rx-decode.opc" 7234 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16); 7235 7236 } 7237 break; 7238 default: UNSUPPORTED(); break; 7239 } 7240 break; 7241 case 0x7f: 7242 GETBYTE (); 7243 switch (op[1] & 0xff) 7244 { 7245 case 0x00: 7246 case 0x01: 7247 case 0x02: 7248 case 0x03: 7249 case 0x04: 7250 case 0x05: 7251 case 0x06: 7252 case 0x07: 7253 case 0x08: 7254 case 0x09: 7255 case 0x0a: 7256 case 0x0b: 7257 case 0x0c: 7258 case 0x0d: 7259 case 0x0e: 7260 case 0x0f: 7261 { 7262 /** 0111 1111 0000 rsrc jmp %0 */ 7263 #line 816 "rx-decode.opc" 7264 int rsrc AU = op[1] & 0x0f; 7265 if (trace) 7266 { 7267 printf ("\033[33m%s\033[0m %02x %02x\n", 7268 "/** 0111 1111 0000 rsrc jmp %0 */", 7269 op[0], op[1]); 7270 printf (" rsrc = 0x%x\n", rsrc); 7271 } 7272 SYNTAX("jmp %0"); 7273 #line 816 "rx-decode.opc" 7274 ID(branch); DR(rsrc); 7275 7276 } 7277 break; 7278 case 0x10: 7279 case 0x11: 7280 case 0x12: 7281 case 0x13: 7282 case 0x14: 7283 case 0x15: 7284 case 0x16: 7285 case 0x17: 7286 case 0x18: 7287 case 0x19: 7288 case 0x1a: 7289 case 0x1b: 7290 case 0x1c: 7291 case 0x1d: 7292 case 0x1e: 7293 case 0x1f: 7294 { 7295 /** 0111 1111 0001 rsrc jsr %0 */ 7296 #line 819 "rx-decode.opc" 7297 int rsrc AU = op[1] & 0x0f; 7298 if (trace) 7299 { 7300 printf ("\033[33m%s\033[0m %02x %02x\n", 7301 "/** 0111 1111 0001 rsrc jsr %0 */", 7302 op[0], op[1]); 7303 printf (" rsrc = 0x%x\n", rsrc); 7304 } 7305 SYNTAX("jsr %0"); 7306 #line 819 "rx-decode.opc" 7307 ID(jsr); DR(rsrc); 7308 7309 } 7310 break; 7311 case 0x40: 7312 case 0x41: 7313 case 0x42: 7314 case 0x43: 7315 case 0x44: 7316 case 0x45: 7317 case 0x46: 7318 case 0x47: 7319 case 0x48: 7320 case 0x49: 7321 case 0x4a: 7322 case 0x4b: 7323 case 0x4c: 7324 case 0x4d: 7325 case 0x4e: 7326 case 0x4f: 7327 { 7328 /** 0111 1111 0100 rsrc bra.l %0 */ 7329 #line 812 "rx-decode.opc" 7330 int rsrc AU = op[1] & 0x0f; 7331 if (trace) 7332 { 7333 printf ("\033[33m%s\033[0m %02x %02x\n", 7334 "/** 0111 1111 0100 rsrc bra.l %0 */", 7335 op[0], op[1]); 7336 printf (" rsrc = 0x%x\n", rsrc); 7337 } 7338 SYNTAX("bra.l %0"); 7339 #line 812 "rx-decode.opc" 7340 ID(branchrel); DR(rsrc); 7341 7342 7343 } 7344 break; 7345 case 0x50: 7346 case 0x51: 7347 case 0x52: 7348 case 0x53: 7349 case 0x54: 7350 case 0x55: 7351 case 0x56: 7352 case 0x57: 7353 case 0x58: 7354 case 0x59: 7355 case 0x5a: 7356 case 0x5b: 7357 case 0x5c: 7358 case 0x5d: 7359 case 0x5e: 7360 case 0x5f: 7361 { 7362 /** 0111 1111 0101 rsrc bsr.l %0 */ 7363 #line 828 "rx-decode.opc" 7364 int rsrc AU = op[1] & 0x0f; 7365 if (trace) 7366 { 7367 printf ("\033[33m%s\033[0m %02x %02x\n", 7368 "/** 0111 1111 0101 rsrc bsr.l %0 */", 7369 op[0], op[1]); 7370 printf (" rsrc = 0x%x\n", rsrc); 7371 } 7372 SYNTAX("bsr.l %0"); 7373 #line 828 "rx-decode.opc" 7374 ID(jsrrel); DR(rsrc); 7375 7376 } 7377 break; 7378 case 0x80: 7379 case 0x81: 7380 case 0x82: 7381 { 7382 /** 0111 1111 1000 00sz suntil%s */ 7383 #line 852 "rx-decode.opc" 7384 int sz AU = op[1] & 0x03; 7385 if (trace) 7386 { 7387 printf ("\033[33m%s\033[0m %02x %02x\n", 7388 "/** 0111 1111 1000 00sz suntil%s */", 7389 op[0], op[1]); 7390 printf (" sz = 0x%x\n", sz); 7391 } 7392 SYNTAX("suntil%s"); 7393 #line 852 "rx-decode.opc" 7394 ID(suntil); BWL(sz); F___ZC; 7395 7396 } 7397 break; 7398 case 0x83: 7399 { 7400 /** 0111 1111 1000 0011 scmpu */ 7401 if (trace) 7402 { 7403 printf ("\033[33m%s\033[0m %02x %02x\n", 7404 "/** 0111 1111 1000 0011 scmpu */", 7405 op[0], op[1]); 7406 } 7407 SYNTAX("scmpu"); 7408 #line 843 "rx-decode.opc" 7409 ID(scmpu); F___ZC; 7410 7411 } 7412 break; 7413 case 0x84: 7414 case 0x85: 7415 case 0x86: 7416 { 7417 /** 0111 1111 1000 01sz swhile%s */ 7418 #line 855 "rx-decode.opc" 7419 int sz AU = op[1] & 0x03; 7420 if (trace) 7421 { 7422 printf ("\033[33m%s\033[0m %02x %02x\n", 7423 "/** 0111 1111 1000 01sz swhile%s */", 7424 op[0], op[1]); 7425 printf (" sz = 0x%x\n", sz); 7426 } 7427 SYNTAX("swhile%s"); 7428 #line 855 "rx-decode.opc" 7429 ID(swhile); BWL(sz); F___ZC; 7430 7431 } 7432 break; 7433 case 0x87: 7434 { 7435 /** 0111 1111 1000 0111 smovu */ 7436 if (trace) 7437 { 7438 printf ("\033[33m%s\033[0m %02x %02x\n", 7439 "/** 0111 1111 1000 0111 smovu */", 7440 op[0], op[1]); 7441 } 7442 SYNTAX("smovu"); 7443 #line 846 "rx-decode.opc" 7444 ID(smovu); 7445 7446 } 7447 break; 7448 case 0x88: 7449 case 0x89: 7450 case 0x8a: 7451 { 7452 /** 0111 1111 1000 10sz sstr%s */ 7453 #line 861 "rx-decode.opc" 7454 int sz AU = op[1] & 0x03; 7455 if (trace) 7456 { 7457 printf ("\033[33m%s\033[0m %02x %02x\n", 7458 "/** 0111 1111 1000 10sz sstr%s */", 7459 op[0], op[1]); 7460 printf (" sz = 0x%x\n", sz); 7461 } 7462 SYNTAX("sstr%s"); 7463 #line 861 "rx-decode.opc" 7464 ID(sstr); BWL(sz); 7465 7466 /*----------------------------------------------------------------------*/ 7467 /* RMPA */ 7468 7469 } 7470 break; 7471 case 0x8b: 7472 { 7473 /** 0111 1111 1000 1011 smovb */ 7474 if (trace) 7475 { 7476 printf ("\033[33m%s\033[0m %02x %02x\n", 7477 "/** 0111 1111 1000 1011 smovb */", 7478 op[0], op[1]); 7479 } 7480 SYNTAX("smovb"); 7481 #line 849 "rx-decode.opc" 7482 ID(smovb); 7483 7484 } 7485 break; 7486 case 0x8c: 7487 case 0x8d: 7488 case 0x8e: 7489 { 7490 /** 0111 1111 1000 11sz rmpa%s */ 7491 #line 867 "rx-decode.opc" 7492 int sz AU = op[1] & 0x03; 7493 if (trace) 7494 { 7495 printf ("\033[33m%s\033[0m %02x %02x\n", 7496 "/** 0111 1111 1000 11sz rmpa%s */", 7497 op[0], op[1]); 7498 printf (" sz = 0x%x\n", sz); 7499 } 7500 SYNTAX("rmpa%s"); 7501 #line 867 "rx-decode.opc" 7502 ID(rmpa); BWL(sz); F_OS__; 7503 7504 /*----------------------------------------------------------------------*/ 7505 /* HI/LO stuff */ 7506 7507 } 7508 break; 7509 case 0x8f: 7510 { 7511 /** 0111 1111 1000 1111 smovf */ 7512 if (trace) 7513 { 7514 printf ("\033[33m%s\033[0m %02x %02x\n", 7515 "/** 0111 1111 1000 1111 smovf */", 7516 op[0], op[1]); 7517 } 7518 SYNTAX("smovf"); 7519 #line 858 "rx-decode.opc" 7520 ID(smovf); 7521 7522 } 7523 break; 7524 case 0x93: 7525 { 7526 /** 0111 1111 1001 0011 satr */ 7527 if (trace) 7528 { 7529 printf ("\033[33m%s\033[0m %02x %02x\n", 7530 "/** 0111 1111 1001 0011 satr */", 7531 op[0], op[1]); 7532 } 7533 SYNTAX("satr"); 7534 #line 909 "rx-decode.opc" 7535 ID(satr); 7536 7537 /*----------------------------------------------------------------------*/ 7538 /* FLOAT */ 7539 7540 } 7541 break; 7542 case 0x94: 7543 { 7544 /** 0111 1111 1001 0100 rtfi */ 7545 if (trace) 7546 { 7547 printf ("\033[33m%s\033[0m %02x %02x\n", 7548 "/** 0111 1111 1001 0100 rtfi */", 7549 op[0], op[1]); 7550 } 7551 SYNTAX("rtfi"); 7552 #line 1044 "rx-decode.opc" 7553 ID(rtfi); 7554 7555 } 7556 break; 7557 case 0x95: 7558 { 7559 /** 0111 1111 1001 0101 rte */ 7560 if (trace) 7561 { 7562 printf ("\033[33m%s\033[0m %02x %02x\n", 7563 "/** 0111 1111 1001 0101 rte */", 7564 op[0], op[1]); 7565 } 7566 SYNTAX("rte"); 7567 #line 1047 "rx-decode.opc" 7568 ID(rte); 7569 7570 } 7571 break; 7572 case 0x96: 7573 { 7574 /** 0111 1111 1001 0110 wait */ 7575 if (trace) 7576 { 7577 printf ("\033[33m%s\033[0m %02x %02x\n", 7578 "/** 0111 1111 1001 0110 wait */", 7579 op[0], op[1]); 7580 } 7581 SYNTAX("wait"); 7582 #line 1059 "rx-decode.opc" 7583 ID(wait); 7584 7585 /*----------------------------------------------------------------------*/ 7586 /* SCcnd */ 7587 7588 } 7589 break; 7590 case 0xa0: 7591 case 0xa1: 7592 case 0xa2: 7593 case 0xa3: 7594 case 0xa4: 7595 case 0xa5: 7596 case 0xa6: 7597 case 0xa7: 7598 case 0xa8: 7599 case 0xa9: 7600 case 0xaa: 7601 case 0xab: 7602 case 0xac: 7603 case 0xad: 7604 case 0xae: 7605 case 0xaf: 7606 { 7607 /** 0111 1111 1010 rdst setpsw %0 */ 7608 #line 1020 "rx-decode.opc" 7609 int rdst AU = op[1] & 0x0f; 7610 if (trace) 7611 { 7612 printf ("\033[33m%s\033[0m %02x %02x\n", 7613 "/** 0111 1111 1010 rdst setpsw %0 */", 7614 op[0], op[1]); 7615 printf (" rdst = 0x%x\n", rdst); 7616 } 7617 SYNTAX("setpsw %0"); 7618 #line 1020 "rx-decode.opc" 7619 ID(setpsw); DF(rdst); 7620 7621 } 7622 break; 7623 case 0xb0: 7624 case 0xb1: 7625 case 0xb2: 7626 case 0xb3: 7627 case 0xb4: 7628 case 0xb5: 7629 case 0xb6: 7630 case 0xb7: 7631 case 0xb8: 7632 case 0xb9: 7633 case 0xba: 7634 case 0xbb: 7635 case 0xbc: 7636 case 0xbd: 7637 case 0xbe: 7638 case 0xbf: 7639 { 7640 /** 0111 1111 1011 rdst clrpsw %0 */ 7641 #line 1017 "rx-decode.opc" 7642 int rdst AU = op[1] & 0x0f; 7643 if (trace) 7644 { 7645 printf ("\033[33m%s\033[0m %02x %02x\n", 7646 "/** 0111 1111 1011 rdst clrpsw %0 */", 7647 op[0], op[1]); 7648 printf (" rdst = 0x%x\n", rdst); 7649 } 7650 SYNTAX("clrpsw %0"); 7651 #line 1017 "rx-decode.opc" 7652 ID(clrpsw); DF(rdst); 7653 7654 } 7655 break; 7656 default: UNSUPPORTED(); break; 7657 } 7658 break; 7659 case 0x80: 7660 GETBYTE (); 7661 switch (op[1] & 0x00) 7662 { 7663 case 0x00: 7664 op_semantics_52: 7665 { 7666 /** 10sz 0dsp a dst b src mov%s %1, %0 */ 7667 #line 357 "rx-decode.opc" 7668 int sz AU = (op[0] >> 4) & 0x03; 7669 #line 357 "rx-decode.opc" 7670 int dsp AU = op[0] & 0x07; 7671 #line 357 "rx-decode.opc" 7672 int a AU = (op[1] >> 7) & 0x01; 7673 #line 357 "rx-decode.opc" 7674 int dst AU = (op[1] >> 4) & 0x07; 7675 #line 357 "rx-decode.opc" 7676 int b AU = (op[1] >> 3) & 0x01; 7677 #line 357 "rx-decode.opc" 7678 int src AU = op[1] & 0x07; 7679 if (trace) 7680 { 7681 printf ("\033[33m%s\033[0m %02x %02x\n", 7682 "/** 10sz 0dsp a dst b src mov%s %1, %0 */", 7683 op[0], op[1]); 7684 printf (" sz = 0x%x,", sz); 7685 printf (" dsp = 0x%x,", dsp); 7686 printf (" a = 0x%x,", a); 7687 printf (" dst = 0x%x,", dst); 7688 printf (" b = 0x%x,", b); 7689 printf (" src = 0x%x\n", src); 7690 } 7691 SYNTAX("mov%s %1, %0"); 7692 #line 357 "rx-decode.opc" 7693 ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F_____; 7694 7695 } 7696 break; 7697 } 7698 break; 7699 case 0x81: 7700 GETBYTE (); 7701 switch (op[1] & 0x00) 7702 { 7703 case 0x00: 7704 goto op_semantics_52; 7705 break; 7706 } 7707 break; 7708 case 0x82: 7709 GETBYTE (); 7710 switch (op[1] & 0x00) 7711 { 7712 case 0x00: 7713 goto op_semantics_52; 7714 break; 7715 } 7716 break; 7717 case 0x83: 7718 GETBYTE (); 7719 switch (op[1] & 0x00) 7720 { 7721 case 0x00: 7722 goto op_semantics_52; 7723 break; 7724 } 7725 break; 7726 case 0x84: 7727 GETBYTE (); 7728 switch (op[1] & 0x00) 7729 { 7730 case 0x00: 7731 goto op_semantics_52; 7732 break; 7733 } 7734 break; 7735 case 0x85: 7736 GETBYTE (); 7737 switch (op[1] & 0x00) 7738 { 7739 case 0x00: 7740 goto op_semantics_52; 7741 break; 7742 } 7743 break; 7744 case 0x86: 7745 GETBYTE (); 7746 switch (op[1] & 0x00) 7747 { 7748 case 0x00: 7749 goto op_semantics_52; 7750 break; 7751 } 7752 break; 7753 case 0x87: 7754 GETBYTE (); 7755 switch (op[1] & 0x00) 7756 { 7757 case 0x00: 7758 goto op_semantics_52; 7759 break; 7760 } 7761 break; 7762 case 0x88: 7763 GETBYTE (); 7764 switch (op[1] & 0x00) 7765 { 7766 case 0x00: 7767 op_semantics_53: 7768 { 7769 /** 10sz 1dsp a src b dst mov%s %1, %0 */ 7770 #line 354 "rx-decode.opc" 7771 int sz AU = (op[0] >> 4) & 0x03; 7772 #line 354 "rx-decode.opc" 7773 int dsp AU = op[0] & 0x07; 7774 #line 354 "rx-decode.opc" 7775 int a AU = (op[1] >> 7) & 0x01; 7776 #line 354 "rx-decode.opc" 7777 int src AU = (op[1] >> 4) & 0x07; 7778 #line 354 "rx-decode.opc" 7779 int b AU = (op[1] >> 3) & 0x01; 7780 #line 354 "rx-decode.opc" 7781 int dst AU = op[1] & 0x07; 7782 if (trace) 7783 { 7784 printf ("\033[33m%s\033[0m %02x %02x\n", 7785 "/** 10sz 1dsp a src b dst mov%s %1, %0 */", 7786 op[0], op[1]); 7787 printf (" sz = 0x%x,", sz); 7788 printf (" dsp = 0x%x,", dsp); 7789 printf (" a = 0x%x,", a); 7790 printf (" src = 0x%x,", src); 7791 printf (" b = 0x%x,", b); 7792 printf (" dst = 0x%x\n", dst); 7793 } 7794 SYNTAX("mov%s %1, %0"); 7795 #line 354 "rx-decode.opc" 7796 ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F_____; 7797 7798 } 7799 break; 7800 } 7801 break; 7802 case 0x89: 7803 GETBYTE (); 7804 switch (op[1] & 0x00) 7805 { 7806 case 0x00: 7807 goto op_semantics_53; 7808 break; 7809 } 7810 break; 7811 case 0x8a: 7812 GETBYTE (); 7813 switch (op[1] & 0x00) 7814 { 7815 case 0x00: 7816 goto op_semantics_53; 7817 break; 7818 } 7819 break; 7820 case 0x8b: 7821 GETBYTE (); 7822 switch (op[1] & 0x00) 7823 { 7824 case 0x00: 7825 goto op_semantics_53; 7826 break; 7827 } 7828 break; 7829 case 0x8c: 7830 GETBYTE (); 7831 switch (op[1] & 0x00) 7832 { 7833 case 0x00: 7834 goto op_semantics_53; 7835 break; 7836 } 7837 break; 7838 case 0x8d: 7839 GETBYTE (); 7840 switch (op[1] & 0x00) 7841 { 7842 case 0x00: 7843 goto op_semantics_53; 7844 break; 7845 } 7846 break; 7847 case 0x8e: 7848 GETBYTE (); 7849 switch (op[1] & 0x00) 7850 { 7851 case 0x00: 7852 goto op_semantics_53; 7853 break; 7854 } 7855 break; 7856 case 0x8f: 7857 GETBYTE (); 7858 switch (op[1] & 0x00) 7859 { 7860 case 0x00: 7861 goto op_semantics_53; 7862 break; 7863 } 7864 break; 7865 case 0x90: 7866 GETBYTE (); 7867 switch (op[1] & 0x00) 7868 { 7869 case 0x00: 7870 goto op_semantics_52; 7871 break; 7872 } 7873 break; 7874 case 0x91: 7875 GETBYTE (); 7876 switch (op[1] & 0x00) 7877 { 7878 case 0x00: 7879 goto op_semantics_52; 7880 break; 7881 } 7882 break; 7883 case 0x92: 7884 GETBYTE (); 7885 switch (op[1] & 0x00) 7886 { 7887 case 0x00: 7888 goto op_semantics_52; 7889 break; 7890 } 7891 break; 7892 case 0x93: 7893 GETBYTE (); 7894 switch (op[1] & 0x00) 7895 { 7896 case 0x00: 7897 goto op_semantics_52; 7898 break; 7899 } 7900 break; 7901 case 0x94: 7902 GETBYTE (); 7903 switch (op[1] & 0x00) 7904 { 7905 case 0x00: 7906 goto op_semantics_52; 7907 break; 7908 } 7909 break; 7910 case 0x95: 7911 GETBYTE (); 7912 switch (op[1] & 0x00) 7913 { 7914 case 0x00: 7915 goto op_semantics_52; 7916 break; 7917 } 7918 break; 7919 case 0x96: 7920 GETBYTE (); 7921 switch (op[1] & 0x00) 7922 { 7923 case 0x00: 7924 goto op_semantics_52; 7925 break; 7926 } 7927 break; 7928 case 0x97: 7929 GETBYTE (); 7930 switch (op[1] & 0x00) 7931 { 7932 case 0x00: 7933 goto op_semantics_52; 7934 break; 7935 } 7936 break; 7937 case 0x98: 7938 GETBYTE (); 7939 switch (op[1] & 0x00) 7940 { 7941 case 0x00: 7942 goto op_semantics_53; 7943 break; 7944 } 7945 break; 7946 case 0x99: 7947 GETBYTE (); 7948 switch (op[1] & 0x00) 7949 { 7950 case 0x00: 7951 goto op_semantics_53; 7952 break; 7953 } 7954 break; 7955 case 0x9a: 7956 GETBYTE (); 7957 switch (op[1] & 0x00) 7958 { 7959 case 0x00: 7960 goto op_semantics_53; 7961 break; 7962 } 7963 break; 7964 case 0x9b: 7965 GETBYTE (); 7966 switch (op[1] & 0x00) 7967 { 7968 case 0x00: 7969 goto op_semantics_53; 7970 break; 7971 } 7972 break; 7973 case 0x9c: 7974 GETBYTE (); 7975 switch (op[1] & 0x00) 7976 { 7977 case 0x00: 7978 goto op_semantics_53; 7979 break; 7980 } 7981 break; 7982 case 0x9d: 7983 GETBYTE (); 7984 switch (op[1] & 0x00) 7985 { 7986 case 0x00: 7987 goto op_semantics_53; 7988 break; 7989 } 7990 break; 7991 case 0x9e: 7992 GETBYTE (); 7993 switch (op[1] & 0x00) 7994 { 7995 case 0x00: 7996 goto op_semantics_53; 7997 break; 7998 } 7999 break; 8000 case 0x9f: 8001 GETBYTE (); 8002 switch (op[1] & 0x00) 8003 { 8004 case 0x00: 8005 goto op_semantics_53; 8006 break; 8007 } 8008 break; 8009 case 0xa0: 8010 GETBYTE (); 8011 switch (op[1] & 0x00) 8012 { 8013 case 0x00: 8014 goto op_semantics_52; 8015 break; 8016 } 8017 break; 8018 case 0xa1: 8019 GETBYTE (); 8020 switch (op[1] & 0x00) 8021 { 8022 case 0x00: 8023 goto op_semantics_52; 8024 break; 8025 } 8026 break; 8027 case 0xa2: 8028 GETBYTE (); 8029 switch (op[1] & 0x00) 8030 { 8031 case 0x00: 8032 goto op_semantics_52; 8033 break; 8034 } 8035 break; 8036 case 0xa3: 8037 GETBYTE (); 8038 switch (op[1] & 0x00) 8039 { 8040 case 0x00: 8041 goto op_semantics_52; 8042 break; 8043 } 8044 break; 8045 case 0xa4: 8046 GETBYTE (); 8047 switch (op[1] & 0x00) 8048 { 8049 case 0x00: 8050 goto op_semantics_52; 8051 break; 8052 } 8053 break; 8054 case 0xa5: 8055 GETBYTE (); 8056 switch (op[1] & 0x00) 8057 { 8058 case 0x00: 8059 goto op_semantics_52; 8060 break; 8061 } 8062 break; 8063 case 0xa6: 8064 GETBYTE (); 8065 switch (op[1] & 0x00) 8066 { 8067 case 0x00: 8068 goto op_semantics_52; 8069 break; 8070 } 8071 break; 8072 case 0xa7: 8073 GETBYTE (); 8074 switch (op[1] & 0x00) 8075 { 8076 case 0x00: 8077 goto op_semantics_52; 8078 break; 8079 } 8080 break; 8081 case 0xa8: 8082 GETBYTE (); 8083 switch (op[1] & 0x00) 8084 { 8085 case 0x00: 8086 goto op_semantics_53; 8087 break; 8088 } 8089 break; 8090 case 0xa9: 8091 GETBYTE (); 8092 switch (op[1] & 0x00) 8093 { 8094 case 0x00: 8095 goto op_semantics_53; 8096 break; 8097 } 8098 break; 8099 case 0xaa: 8100 GETBYTE (); 8101 switch (op[1] & 0x00) 8102 { 8103 case 0x00: 8104 goto op_semantics_53; 8105 break; 8106 } 8107 break; 8108 case 0xab: 8109 GETBYTE (); 8110 switch (op[1] & 0x00) 8111 { 8112 case 0x00: 8113 goto op_semantics_53; 8114 break; 8115 } 8116 break; 8117 case 0xac: 8118 GETBYTE (); 8119 switch (op[1] & 0x00) 8120 { 8121 case 0x00: 8122 goto op_semantics_53; 8123 break; 8124 } 8125 break; 8126 case 0xad: 8127 GETBYTE (); 8128 switch (op[1] & 0x00) 8129 { 8130 case 0x00: 8131 goto op_semantics_53; 8132 break; 8133 } 8134 break; 8135 case 0xae: 8136 GETBYTE (); 8137 switch (op[1] & 0x00) 8138 { 8139 case 0x00: 8140 goto op_semantics_53; 8141 break; 8142 } 8143 break; 8144 case 0xaf: 8145 GETBYTE (); 8146 switch (op[1] & 0x00) 8147 { 8148 case 0x00: 8149 goto op_semantics_53; 8150 break; 8151 } 8152 break; 8153 case 0xb0: 8154 GETBYTE (); 8155 switch (op[1] & 0x00) 8156 { 8157 case 0x00: 8158 op_semantics_54: 8159 { 8160 /** 1011 w dsp a src b dst movu%s %1, %0 */ 8161 #line 377 "rx-decode.opc" 8162 int w AU = (op[0] >> 3) & 0x01; 8163 #line 377 "rx-decode.opc" 8164 int dsp AU = op[0] & 0x07; 8165 #line 377 "rx-decode.opc" 8166 int a AU = (op[1] >> 7) & 0x01; 8167 #line 377 "rx-decode.opc" 8168 int src AU = (op[1] >> 4) & 0x07; 8169 #line 377 "rx-decode.opc" 8170 int b AU = (op[1] >> 3) & 0x01; 8171 #line 377 "rx-decode.opc" 8172 int dst AU = op[1] & 0x07; 8173 if (trace) 8174 { 8175 printf ("\033[33m%s\033[0m %02x %02x\n", 8176 "/** 1011 w dsp a src b dst movu%s %1, %0 */", 8177 op[0], op[1]); 8178 printf (" w = 0x%x,", w); 8179 printf (" dsp = 0x%x,", dsp); 8180 printf (" a = 0x%x,", a); 8181 printf (" src = 0x%x,", src); 8182 printf (" b = 0x%x,", b); 8183 printf (" dst = 0x%x\n", dst); 8184 } 8185 SYNTAX("movu%s %1, %0"); 8186 #line 377 "rx-decode.opc" 8187 ID(mov); uBW(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F_____; 8188 8189 } 8190 break; 8191 } 8192 break; 8193 case 0xb1: 8194 GETBYTE (); 8195 switch (op[1] & 0x00) 8196 { 8197 case 0x00: 8198 goto op_semantics_54; 8199 break; 8200 } 8201 break; 8202 case 0xb2: 8203 GETBYTE (); 8204 switch (op[1] & 0x00) 8205 { 8206 case 0x00: 8207 goto op_semantics_54; 8208 break; 8209 } 8210 break; 8211 case 0xb3: 8212 GETBYTE (); 8213 switch (op[1] & 0x00) 8214 { 8215 case 0x00: 8216 goto op_semantics_54; 8217 break; 8218 } 8219 break; 8220 case 0xb4: 8221 GETBYTE (); 8222 switch (op[1] & 0x00) 8223 { 8224 case 0x00: 8225 goto op_semantics_54; 8226 break; 8227 } 8228 break; 8229 case 0xb5: 8230 GETBYTE (); 8231 switch (op[1] & 0x00) 8232 { 8233 case 0x00: 8234 goto op_semantics_54; 8235 break; 8236 } 8237 break; 8238 case 0xb6: 8239 GETBYTE (); 8240 switch (op[1] & 0x00) 8241 { 8242 case 0x00: 8243 goto op_semantics_54; 8244 break; 8245 } 8246 break; 8247 case 0xb7: 8248 GETBYTE (); 8249 switch (op[1] & 0x00) 8250 { 8251 case 0x00: 8252 goto op_semantics_54; 8253 break; 8254 } 8255 break; 8256 case 0xb8: 8257 GETBYTE (); 8258 switch (op[1] & 0x00) 8259 { 8260 case 0x00: 8261 goto op_semantics_54; 8262 break; 8263 } 8264 break; 8265 case 0xb9: 8266 GETBYTE (); 8267 switch (op[1] & 0x00) 8268 { 8269 case 0x00: 8270 goto op_semantics_54; 8271 break; 8272 } 8273 break; 8274 case 0xba: 8275 GETBYTE (); 8276 switch (op[1] & 0x00) 8277 { 8278 case 0x00: 8279 goto op_semantics_54; 8280 break; 8281 } 8282 break; 8283 case 0xbb: 8284 GETBYTE (); 8285 switch (op[1] & 0x00) 8286 { 8287 case 0x00: 8288 goto op_semantics_54; 8289 break; 8290 } 8291 break; 8292 case 0xbc: 8293 GETBYTE (); 8294 switch (op[1] & 0x00) 8295 { 8296 case 0x00: 8297 goto op_semantics_54; 8298 break; 8299 } 8300 break; 8301 case 0xbd: 8302 GETBYTE (); 8303 switch (op[1] & 0x00) 8304 { 8305 case 0x00: 8306 goto op_semantics_54; 8307 break; 8308 } 8309 break; 8310 case 0xbe: 8311 GETBYTE (); 8312 switch (op[1] & 0x00) 8313 { 8314 case 0x00: 8315 goto op_semantics_54; 8316 break; 8317 } 8318 break; 8319 case 0xbf: 8320 GETBYTE (); 8321 switch (op[1] & 0x00) 8322 { 8323 case 0x00: 8324 goto op_semantics_54; 8325 break; 8326 } 8327 break; 8328 case 0xc0: 8329 GETBYTE (); 8330 switch (op[1] & 0x00) 8331 { 8332 case 0x00: 8333 op_semantics_55: 8334 { 8335 /** 11sz sd ss rsrc rdst mov%s %1, %0 */ 8336 #line 335 "rx-decode.opc" 8337 int sz AU = (op[0] >> 4) & 0x03; 8338 #line 335 "rx-decode.opc" 8339 int sd AU = (op[0] >> 2) & 0x03; 8340 #line 335 "rx-decode.opc" 8341 int ss AU = op[0] & 0x03; 8342 #line 335 "rx-decode.opc" 8343 int rsrc AU = (op[1] >> 4) & 0x0f; 8344 #line 335 "rx-decode.opc" 8345 int rdst AU = op[1] & 0x0f; 8346 if (trace) 8347 { 8348 printf ("\033[33m%s\033[0m %02x %02x\n", 8349 "/** 11sz sd ss rsrc rdst mov%s %1, %0 */", 8350 op[0], op[1]); 8351 printf (" sz = 0x%x,", sz); 8352 printf (" sd = 0x%x,", sd); 8353 printf (" ss = 0x%x,", ss); 8354 printf (" rsrc = 0x%x,", rsrc); 8355 printf (" rdst = 0x%x\n", rdst); 8356 } 8357 SYNTAX("mov%s %1, %0"); 8358 #line 335 "rx-decode.opc" 8359 if (sd == 3 && ss == 3 && sz == 2 && rsrc == 0 && rdst == 0) 8360 { 8361 ID(nop2); 8362 SYNTAX ("nop\t; mov.l\tr0, r0"); 8363 } 8364 else 8365 { 8366 ID(mov); sBWL(sz); F_____; 8367 if ((ss == 3) && (sd != 3)) 8368 { 8369 SD(ss, rdst, sz); DD(sd, rsrc, sz); 8370 } 8371 else 8372 { 8373 SD(ss, rsrc, sz); DD(sd, rdst, sz); 8374 } 8375 } 8376 8377 } 8378 break; 8379 } 8380 break; 8381 case 0xc1: 8382 GETBYTE (); 8383 switch (op[1] & 0x00) 8384 { 8385 case 0x00: 8386 goto op_semantics_55; 8387 break; 8388 } 8389 break; 8390 case 0xc2: 8391 GETBYTE (); 8392 switch (op[1] & 0x00) 8393 { 8394 case 0x00: 8395 goto op_semantics_55; 8396 break; 8397 } 8398 break; 8399 case 0xc3: 8400 GETBYTE (); 8401 switch (op[1] & 0x00) 8402 { 8403 case 0x00: 8404 goto op_semantics_55; 8405 break; 8406 } 8407 break; 8408 case 0xc4: 8409 GETBYTE (); 8410 switch (op[1] & 0x00) 8411 { 8412 case 0x00: 8413 goto op_semantics_55; 8414 break; 8415 } 8416 break; 8417 case 0xc5: 8418 GETBYTE (); 8419 switch (op[1] & 0x00) 8420 { 8421 case 0x00: 8422 goto op_semantics_55; 8423 break; 8424 } 8425 break; 8426 case 0xc6: 8427 GETBYTE (); 8428 switch (op[1] & 0x00) 8429 { 8430 case 0x00: 8431 goto op_semantics_55; 8432 break; 8433 } 8434 break; 8435 case 0xc7: 8436 GETBYTE (); 8437 switch (op[1] & 0x00) 8438 { 8439 case 0x00: 8440 goto op_semantics_55; 8441 break; 8442 } 8443 break; 8444 case 0xc8: 8445 GETBYTE (); 8446 switch (op[1] & 0x00) 8447 { 8448 case 0x00: 8449 goto op_semantics_55; 8450 break; 8451 } 8452 break; 8453 case 0xc9: 8454 GETBYTE (); 8455 switch (op[1] & 0x00) 8456 { 8457 case 0x00: 8458 goto op_semantics_55; 8459 break; 8460 } 8461 break; 8462 case 0xca: 8463 GETBYTE (); 8464 switch (op[1] & 0x00) 8465 { 8466 case 0x00: 8467 goto op_semantics_55; 8468 break; 8469 } 8470 break; 8471 case 0xcb: 8472 GETBYTE (); 8473 switch (op[1] & 0x00) 8474 { 8475 case 0x00: 8476 goto op_semantics_55; 8477 break; 8478 } 8479 break; 8480 case 0xcc: 8481 GETBYTE (); 8482 switch (op[1] & 0x00) 8483 { 8484 case 0x00: 8485 goto op_semantics_55; 8486 break; 8487 } 8488 break; 8489 case 0xcd: 8490 GETBYTE (); 8491 switch (op[1] & 0x00) 8492 { 8493 case 0x00: 8494 goto op_semantics_55; 8495 break; 8496 } 8497 break; 8498 case 0xce: 8499 GETBYTE (); 8500 switch (op[1] & 0x00) 8501 { 8502 case 0x00: 8503 goto op_semantics_55; 8504 break; 8505 } 8506 break; 8507 case 0xcf: 8508 GETBYTE (); 8509 switch (op[1] & 0x00) 8510 { 8511 case 0x00: 8512 goto op_semantics_55; 8513 break; 8514 } 8515 break; 8516 case 0xd0: 8517 GETBYTE (); 8518 switch (op[1] & 0x00) 8519 { 8520 case 0x00: 8521 goto op_semantics_55; 8522 break; 8523 } 8524 break; 8525 case 0xd1: 8526 GETBYTE (); 8527 switch (op[1] & 0x00) 8528 { 8529 case 0x00: 8530 goto op_semantics_55; 8531 break; 8532 } 8533 break; 8534 case 0xd2: 8535 GETBYTE (); 8536 switch (op[1] & 0x00) 8537 { 8538 case 0x00: 8539 goto op_semantics_55; 8540 break; 8541 } 8542 break; 8543 case 0xd3: 8544 GETBYTE (); 8545 switch (op[1] & 0x00) 8546 { 8547 case 0x00: 8548 goto op_semantics_55; 8549 break; 8550 } 8551 break; 8552 case 0xd4: 8553 GETBYTE (); 8554 switch (op[1] & 0x00) 8555 { 8556 case 0x00: 8557 goto op_semantics_55; 8558 break; 8559 } 8560 break; 8561 case 0xd5: 8562 GETBYTE (); 8563 switch (op[1] & 0x00) 8564 { 8565 case 0x00: 8566 goto op_semantics_55; 8567 break; 8568 } 8569 break; 8570 case 0xd6: 8571 GETBYTE (); 8572 switch (op[1] & 0x00) 8573 { 8574 case 0x00: 8575 goto op_semantics_55; 8576 break; 8577 } 8578 break; 8579 case 0xd7: 8580 GETBYTE (); 8581 switch (op[1] & 0x00) 8582 { 8583 case 0x00: 8584 goto op_semantics_55; 8585 break; 8586 } 8587 break; 8588 case 0xd8: 8589 GETBYTE (); 8590 switch (op[1] & 0x00) 8591 { 8592 case 0x00: 8593 goto op_semantics_55; 8594 break; 8595 } 8596 break; 8597 case 0xd9: 8598 GETBYTE (); 8599 switch (op[1] & 0x00) 8600 { 8601 case 0x00: 8602 goto op_semantics_55; 8603 break; 8604 } 8605 break; 8606 case 0xda: 8607 GETBYTE (); 8608 switch (op[1] & 0x00) 8609 { 8610 case 0x00: 8611 goto op_semantics_55; 8612 break; 8613 } 8614 break; 8615 case 0xdb: 8616 GETBYTE (); 8617 switch (op[1] & 0x00) 8618 { 8619 case 0x00: 8620 goto op_semantics_55; 8621 break; 8622 } 8623 break; 8624 case 0xdc: 8625 GETBYTE (); 8626 switch (op[1] & 0x00) 8627 { 8628 case 0x00: 8629 goto op_semantics_55; 8630 break; 8631 } 8632 break; 8633 case 0xdd: 8634 GETBYTE (); 8635 switch (op[1] & 0x00) 8636 { 8637 case 0x00: 8638 goto op_semantics_55; 8639 break; 8640 } 8641 break; 8642 case 0xde: 8643 GETBYTE (); 8644 switch (op[1] & 0x00) 8645 { 8646 case 0x00: 8647 goto op_semantics_55; 8648 break; 8649 } 8650 break; 8651 case 0xdf: 8652 GETBYTE (); 8653 switch (op[1] & 0x00) 8654 { 8655 case 0x00: 8656 goto op_semantics_55; 8657 break; 8658 } 8659 break; 8660 case 0xe0: 8661 GETBYTE (); 8662 switch (op[1] & 0x00) 8663 { 8664 case 0x00: 8665 goto op_semantics_55; 8666 break; 8667 } 8668 break; 8669 case 0xe1: 8670 GETBYTE (); 8671 switch (op[1] & 0x00) 8672 { 8673 case 0x00: 8674 goto op_semantics_55; 8675 break; 8676 } 8677 break; 8678 case 0xe2: 8679 GETBYTE (); 8680 switch (op[1] & 0x00) 8681 { 8682 case 0x00: 8683 goto op_semantics_55; 8684 break; 8685 } 8686 break; 8687 case 0xe3: 8688 GETBYTE (); 8689 switch (op[1] & 0x00) 8690 { 8691 case 0x00: 8692 goto op_semantics_55; 8693 break; 8694 } 8695 break; 8696 case 0xe4: 8697 GETBYTE (); 8698 switch (op[1] & 0x00) 8699 { 8700 case 0x00: 8701 goto op_semantics_55; 8702 break; 8703 } 8704 break; 8705 case 0xe5: 8706 GETBYTE (); 8707 switch (op[1] & 0x00) 8708 { 8709 case 0x00: 8710 goto op_semantics_55; 8711 break; 8712 } 8713 break; 8714 case 0xe6: 8715 GETBYTE (); 8716 switch (op[1] & 0x00) 8717 { 8718 case 0x00: 8719 goto op_semantics_55; 8720 break; 8721 } 8722 break; 8723 case 0xe7: 8724 GETBYTE (); 8725 switch (op[1] & 0x00) 8726 { 8727 case 0x00: 8728 goto op_semantics_55; 8729 break; 8730 } 8731 break; 8732 case 0xe8: 8733 GETBYTE (); 8734 switch (op[1] & 0x00) 8735 { 8736 case 0x00: 8737 goto op_semantics_55; 8738 break; 8739 } 8740 break; 8741 case 0xe9: 8742 GETBYTE (); 8743 switch (op[1] & 0x00) 8744 { 8745 case 0x00: 8746 goto op_semantics_55; 8747 break; 8748 } 8749 break; 8750 case 0xea: 8751 GETBYTE (); 8752 switch (op[1] & 0x00) 8753 { 8754 case 0x00: 8755 goto op_semantics_55; 8756 break; 8757 } 8758 break; 8759 case 0xeb: 8760 GETBYTE (); 8761 switch (op[1] & 0x00) 8762 { 8763 case 0x00: 8764 goto op_semantics_55; 8765 break; 8766 } 8767 break; 8768 case 0xec: 8769 GETBYTE (); 8770 switch (op[1] & 0x00) 8771 { 8772 case 0x00: 8773 goto op_semantics_55; 8774 break; 8775 } 8776 break; 8777 case 0xed: 8778 GETBYTE (); 8779 switch (op[1] & 0x00) 8780 { 8781 case 0x00: 8782 goto op_semantics_55; 8783 break; 8784 } 8785 break; 8786 case 0xee: 8787 GETBYTE (); 8788 switch (op[1] & 0x00) 8789 { 8790 case 0x00: 8791 goto op_semantics_55; 8792 break; 8793 } 8794 break; 8795 case 0xef: 8796 GETBYTE (); 8797 switch (op[1] & 0x00) 8798 { 8799 case 0x00: 8800 goto op_semantics_55; 8801 break; 8802 } 8803 break; 8804 case 0xf0: 8805 GETBYTE (); 8806 switch (op[1] & 0x08) 8807 { 8808 case 0x00: 8809 op_semantics_56: 8810 { 8811 /** 1111 00sd rdst 0bit bset #%1, %0%S0 */ 8812 #line 960 "rx-decode.opc" 8813 int sd AU = op[0] & 0x03; 8814 #line 960 "rx-decode.opc" 8815 int rdst AU = (op[1] >> 4) & 0x0f; 8816 #line 960 "rx-decode.opc" 8817 int bit AU = op[1] & 0x07; 8818 if (trace) 8819 { 8820 printf ("\033[33m%s\033[0m %02x %02x\n", 8821 "/** 1111 00sd rdst 0bit bset #%1, %0%S0 */", 8822 op[0], op[1]); 8823 printf (" sd = 0x%x,", sd); 8824 printf (" rdst = 0x%x,", rdst); 8825 printf (" bit = 0x%x\n", bit); 8826 } 8827 SYNTAX("bset #%1, %0%S0"); 8828 #line 960 "rx-decode.opc" 8829 ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____; 8830 8831 } 8832 break; 8833 case 0x08: 8834 op_semantics_57: 8835 { 8836 /** 1111 00sd rdst 1bit bclr #%1, %0%S0 */ 8837 #line 972 "rx-decode.opc" 8838 int sd AU = op[0] & 0x03; 8839 #line 972 "rx-decode.opc" 8840 int rdst AU = (op[1] >> 4) & 0x0f; 8841 #line 972 "rx-decode.opc" 8842 int bit AU = op[1] & 0x07; 8843 if (trace) 8844 { 8845 printf ("\033[33m%s\033[0m %02x %02x\n", 8846 "/** 1111 00sd rdst 1bit bclr #%1, %0%S0 */", 8847 op[0], op[1]); 8848 printf (" sd = 0x%x,", sd); 8849 printf (" rdst = 0x%x,", rdst); 8850 printf (" bit = 0x%x\n", bit); 8851 } 8852 SYNTAX("bclr #%1, %0%S0"); 8853 #line 972 "rx-decode.opc" 8854 ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____; 8855 8856 } 8857 break; 8858 } 8859 break; 8860 case 0xf1: 8861 GETBYTE (); 8862 switch (op[1] & 0x08) 8863 { 8864 case 0x00: 8865 goto op_semantics_56; 8866 break; 8867 case 0x08: 8868 goto op_semantics_57; 8869 break; 8870 } 8871 break; 8872 case 0xf2: 8873 GETBYTE (); 8874 switch (op[1] & 0x08) 8875 { 8876 case 0x00: 8877 goto op_semantics_56; 8878 break; 8879 case 0x08: 8880 goto op_semantics_57; 8881 break; 8882 } 8883 break; 8884 case 0xf3: 8885 GETBYTE (); 8886 switch (op[1] & 0x08) 8887 { 8888 case 0x00: 8889 goto op_semantics_56; 8890 break; 8891 case 0x08: 8892 goto op_semantics_57; 8893 break; 8894 } 8895 break; 8896 case 0xf4: 8897 GETBYTE (); 8898 switch (op[1] & 0x0c) 8899 { 8900 case 0x00: 8901 case 0x04: 8902 op_semantics_58: 8903 { 8904 /** 1111 01sd rdst 0bit btst #%2, %1%S1 */ 8905 #line 984 "rx-decode.opc" 8906 int sd AU = op[0] & 0x03; 8907 #line 984 "rx-decode.opc" 8908 int rdst AU = (op[1] >> 4) & 0x0f; 8909 #line 984 "rx-decode.opc" 8910 int bit AU = op[1] & 0x07; 8911 if (trace) 8912 { 8913 printf ("\033[33m%s\033[0m %02x %02x\n", 8914 "/** 1111 01sd rdst 0bit btst #%2, %1%S1 */", 8915 op[0], op[1]); 8916 printf (" sd = 0x%x,", sd); 8917 printf (" rdst = 0x%x,", rdst); 8918 printf (" bit = 0x%x\n", bit); 8919 } 8920 SYNTAX("btst #%2, %1%S1"); 8921 #line 984 "rx-decode.opc" 8922 ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F___ZC; 8923 8924 } 8925 break; 8926 case 0x08: 8927 op_semantics_59: 8928 { 8929 /** 1111 01ss rsrc 10sz push%s %1 */ 8930 #line 402 "rx-decode.opc" 8931 int ss AU = op[0] & 0x03; 8932 #line 402 "rx-decode.opc" 8933 int rsrc AU = (op[1] >> 4) & 0x0f; 8934 #line 402 "rx-decode.opc" 8935 int sz AU = op[1] & 0x03; 8936 if (trace) 8937 { 8938 printf ("\033[33m%s\033[0m %02x %02x\n", 8939 "/** 1111 01ss rsrc 10sz push%s %1 */", 8940 op[0], op[1]); 8941 printf (" ss = 0x%x,", ss); 8942 printf (" rsrc = 0x%x,", rsrc); 8943 printf (" sz = 0x%x\n", sz); 8944 } 8945 SYNTAX("push%s %1"); 8946 #line 402 "rx-decode.opc" 8947 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F_____; 8948 8949 /*----------------------------------------------------------------------*/ 8950 /* XCHG */ 8951 8952 } 8953 break; 8954 default: UNSUPPORTED(); break; 8955 } 8956 break; 8957 case 0xf5: 8958 GETBYTE (); 8959 switch (op[1] & 0x0c) 8960 { 8961 case 0x00: 8962 case 0x04: 8963 goto op_semantics_58; 8964 break; 8965 case 0x08: 8966 goto op_semantics_59; 8967 break; 8968 default: UNSUPPORTED(); break; 8969 } 8970 break; 8971 case 0xf6: 8972 GETBYTE (); 8973 switch (op[1] & 0x0c) 8974 { 8975 case 0x00: 8976 case 0x04: 8977 goto op_semantics_58; 8978 break; 8979 case 0x08: 8980 goto op_semantics_59; 8981 break; 8982 default: UNSUPPORTED(); break; 8983 } 8984 break; 8985 case 0xf7: 8986 GETBYTE (); 8987 switch (op[1] & 0x0c) 8988 { 8989 case 0x00: 8990 case 0x04: 8991 goto op_semantics_58; 8992 break; 8993 case 0x08: 8994 goto op_semantics_59; 8995 break; 8996 default: UNSUPPORTED(); break; 8997 } 8998 break; 8999 case 0xf8: 9000 GETBYTE (); 9001 switch (op[1] & 0x00) 9002 { 9003 case 0x00: 9004 op_semantics_60: 9005 { 9006 /** 1111 10sd rdst im sz mov%s #%1, %0 */ 9007 #line 313 "rx-decode.opc" 9008 int sd AU = op[0] & 0x03; 9009 #line 313 "rx-decode.opc" 9010 int rdst AU = (op[1] >> 4) & 0x0f; 9011 #line 313 "rx-decode.opc" 9012 int im AU = (op[1] >> 2) & 0x03; 9013 #line 313 "rx-decode.opc" 9014 int sz AU = op[1] & 0x03; 9015 if (trace) 9016 { 9017 printf ("\033[33m%s\033[0m %02x %02x\n", 9018 "/** 1111 10sd rdst im sz mov%s #%1, %0 */", 9019 op[0], op[1]); 9020 printf (" sd = 0x%x,", sd); 9021 printf (" rdst = 0x%x,", rdst); 9022 printf (" im = 0x%x,", im); 9023 printf (" sz = 0x%x\n", sz); 9024 } 9025 SYNTAX("mov%s #%1, %0"); 9026 #line 313 "rx-decode.opc" 9027 ID(mov); DD(sd, rdst, sz); 9028 if ((im == 1 && sz == 0) 9029 || (im == 2 && sz == 1) 9030 || (im == 0 && sz == 2)) 9031 { 9032 BWL (sz); 9033 SC(IMM(im)); 9034 } 9035 else 9036 { 9037 sBWL (sz); 9038 SC(IMMex(im)); 9039 } 9040 F_____; 9041 9042 } 9043 break; 9044 } 9045 break; 9046 case 0xf9: 9047 GETBYTE (); 9048 switch (op[1] & 0xff) 9049 { 9050 case 0x00: 9051 case 0x01: 9052 case 0x02: 9053 case 0x04: 9054 case 0x05: 9055 case 0x06: 9056 case 0x08: 9057 case 0x09: 9058 case 0x0a: 9059 case 0x0c: 9060 case 0x0d: 9061 case 0x0e: 9062 case 0x10: 9063 case 0x11: 9064 case 0x12: 9065 case 0x14: 9066 case 0x15: 9067 case 0x16: 9068 case 0x18: 9069 case 0x19: 9070 case 0x1a: 9071 case 0x1c: 9072 case 0x1d: 9073 case 0x1e: 9074 case 0x20: 9075 case 0x21: 9076 case 0x22: 9077 case 0x24: 9078 case 0x25: 9079 case 0x26: 9080 case 0x28: 9081 case 0x29: 9082 case 0x2a: 9083 case 0x2c: 9084 case 0x2d: 9085 case 0x2e: 9086 case 0x30: 9087 case 0x31: 9088 case 0x32: 9089 case 0x34: 9090 case 0x35: 9091 case 0x36: 9092 case 0x38: 9093 case 0x39: 9094 case 0x3a: 9095 case 0x3c: 9096 case 0x3d: 9097 case 0x3e: 9098 case 0x40: 9099 case 0x41: 9100 case 0x42: 9101 case 0x44: 9102 case 0x45: 9103 case 0x46: 9104 case 0x48: 9105 case 0x49: 9106 case 0x4a: 9107 case 0x4c: 9108 case 0x4d: 9109 case 0x4e: 9110 case 0x50: 9111 case 0x51: 9112 case 0x52: 9113 case 0x54: 9114 case 0x55: 9115 case 0x56: 9116 case 0x58: 9117 case 0x59: 9118 case 0x5a: 9119 case 0x5c: 9120 case 0x5d: 9121 case 0x5e: 9122 case 0x60: 9123 case 0x61: 9124 case 0x62: 9125 case 0x64: 9126 case 0x65: 9127 case 0x66: 9128 case 0x68: 9129 case 0x69: 9130 case 0x6a: 9131 case 0x6c: 9132 case 0x6d: 9133 case 0x6e: 9134 case 0x70: 9135 case 0x71: 9136 case 0x72: 9137 case 0x74: 9138 case 0x75: 9139 case 0x76: 9140 case 0x78: 9141 case 0x79: 9142 case 0x7a: 9143 case 0x7c: 9144 case 0x7d: 9145 case 0x7e: 9146 case 0x80: 9147 case 0x81: 9148 case 0x82: 9149 case 0x84: 9150 case 0x85: 9151 case 0x86: 9152 case 0x88: 9153 case 0x89: 9154 case 0x8a: 9155 case 0x8c: 9156 case 0x8d: 9157 case 0x8e: 9158 case 0x90: 9159 case 0x91: 9160 case 0x92: 9161 case 0x94: 9162 case 0x95: 9163 case 0x96: 9164 case 0x98: 9165 case 0x99: 9166 case 0x9a: 9167 case 0x9c: 9168 case 0x9d: 9169 case 0x9e: 9170 case 0xa0: 9171 case 0xa1: 9172 case 0xa2: 9173 case 0xa4: 9174 case 0xa5: 9175 case 0xa6: 9176 case 0xa8: 9177 case 0xa9: 9178 case 0xaa: 9179 case 0xac: 9180 case 0xad: 9181 case 0xae: 9182 case 0xb0: 9183 case 0xb1: 9184 case 0xb2: 9185 case 0xb4: 9186 case 0xb5: 9187 case 0xb6: 9188 case 0xb8: 9189 case 0xb9: 9190 case 0xba: 9191 case 0xbc: 9192 case 0xbd: 9193 case 0xbe: 9194 case 0xc0: 9195 case 0xc1: 9196 case 0xc2: 9197 case 0xc4: 9198 case 0xc5: 9199 case 0xc6: 9200 case 0xc8: 9201 case 0xc9: 9202 case 0xca: 9203 case 0xcc: 9204 case 0xcd: 9205 case 0xce: 9206 case 0xd0: 9207 case 0xd1: 9208 case 0xd2: 9209 case 0xd4: 9210 case 0xd5: 9211 case 0xd6: 9212 case 0xd8: 9213 case 0xd9: 9214 case 0xda: 9215 case 0xdc: 9216 case 0xdd: 9217 case 0xde: 9218 case 0xe0: 9219 case 0xe1: 9220 case 0xe2: 9221 case 0xe4: 9222 case 0xe5: 9223 case 0xe6: 9224 case 0xe8: 9225 case 0xe9: 9226 case 0xea: 9227 case 0xec: 9228 case 0xed: 9229 case 0xee: 9230 case 0xf0: 9231 case 0xf1: 9232 case 0xf2: 9233 case 0xf4: 9234 case 0xf5: 9235 case 0xf6: 9236 case 0xf8: 9237 case 0xf9: 9238 case 0xfa: 9239 case 0xfc: 9240 case 0xfd: 9241 case 0xfe: 9242 goto op_semantics_60; 9243 break; 9244 case 0x03: 9245 GETBYTE (); 9246 switch (op[2] & 0x0f) 9247 { 9248 case 0x00: 9249 { 9250 /** 1111 1001 0000 0011 rdst 0000 dmov.l #%1, %0 */ 9251 #line 1211 "rx-decode.opc" 9252 int rdst AU = (op[2] >> 4) & 0x0f; 9253 if (trace) 9254 { 9255 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9256 "/** 1111 1001 0000 0011 rdst 0000 dmov.l #%1, %0 */", 9257 op[0], op[1], op[2]); 9258 printf (" rdst = 0x%x\n", rdst); 9259 } 9260 SYNTAX("dmov.l #%1, %0"); 9261 #line 1211 "rx-decode.opc" 9262 ID(dmov); DDRL(rdst); SC(IMMex(0)); F_____; 9263 9264 } 9265 break; 9266 case 0x02: 9267 case 0x03: 9268 { 9269 /** 1111 1001 0000 0011 rdst 001s dmov%s #%1, %0 */ 9270 #line 1208 "rx-decode.opc" 9271 int rdst AU = (op[2] >> 4) & 0x0f; 9272 #line 1208 "rx-decode.opc" 9273 int s AU = op[2] & 0x01; 9274 if (trace) 9275 { 9276 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9277 "/** 1111 1001 0000 0011 rdst 001s dmov%s #%1, %0 */", 9278 op[0], op[1], op[2]); 9279 printf (" rdst = 0x%x,", rdst); 9280 printf (" s = 0x%x\n", s); 9281 } 9282 SYNTAX("dmov%s #%1, %0"); 9283 #line 1208 "rx-decode.opc" 9284 ID(dmov); DDRH(rdst); DL(s); SC(IMMex(0)); F_____; 9285 9286 } 9287 break; 9288 default: UNSUPPORTED(); break; 9289 } 9290 break; 9291 default: UNSUPPORTED(); break; 9292 } 9293 break; 9294 case 0xfa: 9295 GETBYTE (); 9296 switch (op[1] & 0x00) 9297 { 9298 case 0x00: 9299 goto op_semantics_60; 9300 break; 9301 } 9302 break; 9303 case 0xfb: 9304 GETBYTE (); 9305 switch (op[1] & 0x00) 9306 { 9307 case 0x00: 9308 goto op_semantics_60; 9309 break; 9310 } 9311 break; 9312 case 0xfc: 9313 GETBYTE (); 9314 switch (op[1] & 0xff) 9315 { 9316 case 0x03: 9317 GETBYTE (); 9318 switch (op[2] & 0x00) 9319 { 9320 case 0x00: 9321 { 9322 /** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */ 9323 #line 576 "rx-decode.opc" 9324 int rsrc AU = (op[2] >> 4) & 0x0f; 9325 #line 576 "rx-decode.opc" 9326 int rdst AU = op[2] & 0x0f; 9327 if (trace) 9328 { 9329 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9330 "/** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */", 9331 op[0], op[1], op[2]); 9332 printf (" rsrc = 0x%x,", rsrc); 9333 printf (" rdst = 0x%x\n", rdst); 9334 } 9335 SYNTAX("sbb %1, %0"); 9336 #line 576 "rx-decode.opc" 9337 ID(sbb); SR (rsrc); DR(rdst); F_OSZC; 9338 9339 /* FIXME: only supports .L */ 9340 } 9341 break; 9342 } 9343 break; 9344 case 0x07: 9345 GETBYTE (); 9346 switch (op[2] & 0x00) 9347 { 9348 case 0x00: 9349 { 9350 /** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */ 9351 #line 507 "rx-decode.opc" 9352 int rsrc AU = (op[2] >> 4) & 0x0f; 9353 #line 507 "rx-decode.opc" 9354 int rdst AU = op[2] & 0x0f; 9355 if (trace) 9356 { 9357 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9358 "/** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */", 9359 op[0], op[1], op[2]); 9360 printf (" rsrc = 0x%x,", rsrc); 9361 printf (" rdst = 0x%x\n", rdst); 9362 } 9363 SYNTAX("neg %2, %0"); 9364 #line 507 "rx-decode.opc" 9365 ID(sub); DR(rdst); SC(0); S2R(rsrc); F_OSZC; 9366 9367 /*----------------------------------------------------------------------*/ 9368 /* ADC */ 9369 9370 } 9371 break; 9372 } 9373 break; 9374 case 0x0b: 9375 GETBYTE (); 9376 switch (op[2] & 0x00) 9377 { 9378 case 0x00: 9379 { 9380 /** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */ 9381 #line 516 "rx-decode.opc" 9382 int rsrc AU = (op[2] >> 4) & 0x0f; 9383 #line 516 "rx-decode.opc" 9384 int rdst AU = op[2] & 0x0f; 9385 if (trace) 9386 { 9387 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9388 "/** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */", 9389 op[0], op[1], op[2]); 9390 printf (" rsrc = 0x%x,", rsrc); 9391 printf (" rdst = 0x%x\n", rdst); 9392 } 9393 SYNTAX("adc %1, %0"); 9394 #line 516 "rx-decode.opc" 9395 ID(adc); SR(rsrc); DR(rdst); F_OSZC; 9396 9397 } 9398 break; 9399 } 9400 break; 9401 case 0x0f: 9402 GETBYTE (); 9403 switch (op[2] & 0x00) 9404 { 9405 case 0x00: 9406 { 9407 /** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */ 9408 #line 589 "rx-decode.opc" 9409 int rsrc AU = (op[2] >> 4) & 0x0f; 9410 #line 589 "rx-decode.opc" 9411 int rdst AU = op[2] & 0x0f; 9412 if (trace) 9413 { 9414 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9415 "/** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */", 9416 op[0], op[1], op[2]); 9417 printf (" rsrc = 0x%x,", rsrc); 9418 printf (" rdst = 0x%x\n", rdst); 9419 } 9420 SYNTAX("abs %1, %0"); 9421 #line 589 "rx-decode.opc" 9422 ID(abs); DR(rdst); SR(rsrc); F_OSZ_; 9423 9424 /*----------------------------------------------------------------------*/ 9425 /* MAX */ 9426 9427 } 9428 break; 9429 } 9430 break; 9431 case 0x10: 9432 GETBYTE (); 9433 switch (op[2] & 0x00) 9434 { 9435 case 0x00: 9436 op_semantics_61: 9437 { 9438 /** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */ 9439 #line 608 "rx-decode.opc" 9440 int ss AU = op[1] & 0x03; 9441 #line 608 "rx-decode.opc" 9442 int rsrc AU = (op[2] >> 4) & 0x0f; 9443 #line 608 "rx-decode.opc" 9444 int rdst AU = op[2] & 0x0f; 9445 if (trace) 9446 { 9447 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9448 "/** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */", 9449 op[0], op[1], op[2]); 9450 printf (" ss = 0x%x,", ss); 9451 printf (" rsrc = 0x%x,", rsrc); 9452 printf (" rdst = 0x%x\n", rdst); 9453 } 9454 SYNTAX("max %1%S1, %0"); 9455 #line 608 "rx-decode.opc" 9456 if (ss == 3 && rsrc == 0 && rdst == 0) 9457 { 9458 ID(nop3); 9459 SYNTAX("nop\t; max\tr0, r0"); 9460 } 9461 else 9462 { 9463 ID(max); SP(ss, rsrc); DR(rdst); 9464 } 9465 9466 } 9467 break; 9468 } 9469 break; 9470 case 0x11: 9471 GETBYTE (); 9472 switch (op[2] & 0x00) 9473 { 9474 case 0x00: 9475 goto op_semantics_61; 9476 break; 9477 } 9478 break; 9479 case 0x12: 9480 GETBYTE (); 9481 switch (op[2] & 0x00) 9482 { 9483 case 0x00: 9484 goto op_semantics_61; 9485 break; 9486 } 9487 break; 9488 case 0x13: 9489 GETBYTE (); 9490 switch (op[2] & 0x00) 9491 { 9492 case 0x00: 9493 goto op_semantics_61; 9494 break; 9495 } 9496 break; 9497 case 0x14: 9498 GETBYTE (); 9499 switch (op[2] & 0x00) 9500 { 9501 case 0x00: 9502 op_semantics_62: 9503 { 9504 /** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */ 9505 #line 628 "rx-decode.opc" 9506 int ss AU = op[1] & 0x03; 9507 #line 628 "rx-decode.opc" 9508 int rsrc AU = (op[2] >> 4) & 0x0f; 9509 #line 628 "rx-decode.opc" 9510 int rdst AU = op[2] & 0x0f; 9511 if (trace) 9512 { 9513 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9514 "/** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */", 9515 op[0], op[1], op[2]); 9516 printf (" ss = 0x%x,", ss); 9517 printf (" rsrc = 0x%x,", rsrc); 9518 printf (" rdst = 0x%x\n", rdst); 9519 } 9520 SYNTAX("min %1%S1, %0"); 9521 #line 628 "rx-decode.opc" 9522 ID(min); SP(ss, rsrc); DR(rdst); 9523 9524 } 9525 break; 9526 } 9527 break; 9528 case 0x15: 9529 GETBYTE (); 9530 switch (op[2] & 0x00) 9531 { 9532 case 0x00: 9533 goto op_semantics_62; 9534 break; 9535 } 9536 break; 9537 case 0x16: 9538 GETBYTE (); 9539 switch (op[2] & 0x00) 9540 { 9541 case 0x00: 9542 goto op_semantics_62; 9543 break; 9544 } 9545 break; 9546 case 0x17: 9547 GETBYTE (); 9548 switch (op[2] & 0x00) 9549 { 9550 case 0x00: 9551 goto op_semantics_62; 9552 break; 9553 } 9554 break; 9555 case 0x18: 9556 GETBYTE (); 9557 switch (op[2] & 0x00) 9558 { 9559 case 0x00: 9560 op_semantics_63: 9561 { 9562 /** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */ 9563 #line 686 "rx-decode.opc" 9564 int ss AU = op[1] & 0x03; 9565 #line 686 "rx-decode.opc" 9566 int rsrc AU = (op[2] >> 4) & 0x0f; 9567 #line 686 "rx-decode.opc" 9568 int rdst AU = op[2] & 0x0f; 9569 if (trace) 9570 { 9571 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9572 "/** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */", 9573 op[0], op[1], op[2]); 9574 printf (" ss = 0x%x,", ss); 9575 printf (" rsrc = 0x%x,", rsrc); 9576 printf (" rdst = 0x%x\n", rdst); 9577 } 9578 SYNTAX("emul %1%S1, %0"); 9579 #line 686 "rx-decode.opc" 9580 ID(emul); SP(ss, rsrc); DR(rdst); 9581 9582 } 9583 break; 9584 } 9585 break; 9586 case 0x19: 9587 GETBYTE (); 9588 switch (op[2] & 0x00) 9589 { 9590 case 0x00: 9591 goto op_semantics_63; 9592 break; 9593 } 9594 break; 9595 case 0x1a: 9596 GETBYTE (); 9597 switch (op[2] & 0x00) 9598 { 9599 case 0x00: 9600 goto op_semantics_63; 9601 break; 9602 } 9603 break; 9604 case 0x1b: 9605 GETBYTE (); 9606 switch (op[2] & 0x00) 9607 { 9608 case 0x00: 9609 goto op_semantics_63; 9610 break; 9611 } 9612 break; 9613 case 0x1c: 9614 GETBYTE (); 9615 switch (op[2] & 0x00) 9616 { 9617 case 0x00: 9618 op_semantics_64: 9619 { 9620 /** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */ 9621 #line 698 "rx-decode.opc" 9622 int ss AU = op[1] & 0x03; 9623 #line 698 "rx-decode.opc" 9624 int rsrc AU = (op[2] >> 4) & 0x0f; 9625 #line 698 "rx-decode.opc" 9626 int rdst AU = op[2] & 0x0f; 9627 if (trace) 9628 { 9629 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9630 "/** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */", 9631 op[0], op[1], op[2]); 9632 printf (" ss = 0x%x,", ss); 9633 printf (" rsrc = 0x%x,", rsrc); 9634 printf (" rdst = 0x%x\n", rdst); 9635 } 9636 SYNTAX("emulu %1%S1, %0"); 9637 #line 698 "rx-decode.opc" 9638 ID(emulu); SP(ss, rsrc); DR(rdst); 9639 9640 } 9641 break; 9642 } 9643 break; 9644 case 0x1d: 9645 GETBYTE (); 9646 switch (op[2] & 0x00) 9647 { 9648 case 0x00: 9649 goto op_semantics_64; 9650 break; 9651 } 9652 break; 9653 case 0x1e: 9654 GETBYTE (); 9655 switch (op[2] & 0x00) 9656 { 9657 case 0x00: 9658 goto op_semantics_64; 9659 break; 9660 } 9661 break; 9662 case 0x1f: 9663 GETBYTE (); 9664 switch (op[2] & 0x00) 9665 { 9666 case 0x00: 9667 goto op_semantics_64; 9668 break; 9669 } 9670 break; 9671 case 0x20: 9672 GETBYTE (); 9673 switch (op[2] & 0x00) 9674 { 9675 case 0x00: 9676 op_semantics_65: 9677 { 9678 /** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */ 9679 #line 710 "rx-decode.opc" 9680 int ss AU = op[1] & 0x03; 9681 #line 710 "rx-decode.opc" 9682 int rsrc AU = (op[2] >> 4) & 0x0f; 9683 #line 710 "rx-decode.opc" 9684 int rdst AU = op[2] & 0x0f; 9685 if (trace) 9686 { 9687 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9688 "/** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */", 9689 op[0], op[1], op[2]); 9690 printf (" ss = 0x%x,", ss); 9691 printf (" rsrc = 0x%x,", rsrc); 9692 printf (" rdst = 0x%x\n", rdst); 9693 } 9694 SYNTAX("div %1%S1, %0"); 9695 #line 710 "rx-decode.opc" 9696 ID(div); SP(ss, rsrc); DR(rdst); F_O___; 9697 9698 } 9699 break; 9700 } 9701 break; 9702 case 0x21: 9703 GETBYTE (); 9704 switch (op[2] & 0x00) 9705 { 9706 case 0x00: 9707 goto op_semantics_65; 9708 break; 9709 } 9710 break; 9711 case 0x22: 9712 GETBYTE (); 9713 switch (op[2] & 0x00) 9714 { 9715 case 0x00: 9716 goto op_semantics_65; 9717 break; 9718 } 9719 break; 9720 case 0x23: 9721 GETBYTE (); 9722 switch (op[2] & 0x00) 9723 { 9724 case 0x00: 9725 goto op_semantics_65; 9726 break; 9727 } 9728 break; 9729 case 0x24: 9730 GETBYTE (); 9731 switch (op[2] & 0x00) 9732 { 9733 case 0x00: 9734 op_semantics_66: 9735 { 9736 /** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */ 9737 #line 722 "rx-decode.opc" 9738 int ss AU = op[1] & 0x03; 9739 #line 722 "rx-decode.opc" 9740 int rsrc AU = (op[2] >> 4) & 0x0f; 9741 #line 722 "rx-decode.opc" 9742 int rdst AU = op[2] & 0x0f; 9743 if (trace) 9744 { 9745 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9746 "/** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */", 9747 op[0], op[1], op[2]); 9748 printf (" ss = 0x%x,", ss); 9749 printf (" rsrc = 0x%x,", rsrc); 9750 printf (" rdst = 0x%x\n", rdst); 9751 } 9752 SYNTAX("divu %1%S1, %0"); 9753 #line 722 "rx-decode.opc" 9754 ID(divu); SP(ss, rsrc); DR(rdst); F_O___; 9755 9756 } 9757 break; 9758 } 9759 break; 9760 case 0x25: 9761 GETBYTE (); 9762 switch (op[2] & 0x00) 9763 { 9764 case 0x00: 9765 goto op_semantics_66; 9766 break; 9767 } 9768 break; 9769 case 0x26: 9770 GETBYTE (); 9771 switch (op[2] & 0x00) 9772 { 9773 case 0x00: 9774 goto op_semantics_66; 9775 break; 9776 } 9777 break; 9778 case 0x27: 9779 GETBYTE (); 9780 switch (op[2] & 0x00) 9781 { 9782 case 0x00: 9783 goto op_semantics_66; 9784 break; 9785 } 9786 break; 9787 case 0x30: 9788 GETBYTE (); 9789 switch (op[2] & 0x00) 9790 { 9791 case 0x00: 9792 op_semantics_67: 9793 { 9794 /** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */ 9795 #line 495 "rx-decode.opc" 9796 int ss AU = op[1] & 0x03; 9797 #line 495 "rx-decode.opc" 9798 int rsrc AU = (op[2] >> 4) & 0x0f; 9799 #line 495 "rx-decode.opc" 9800 int rdst AU = op[2] & 0x0f; 9801 if (trace) 9802 { 9803 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9804 "/** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */", 9805 op[0], op[1], op[2]); 9806 printf (" ss = 0x%x,", ss); 9807 printf (" rsrc = 0x%x,", rsrc); 9808 printf (" rdst = 0x%x\n", rdst); 9809 } 9810 SYNTAX("tst %1%S1, %2"); 9811 #line 495 "rx-decode.opc" 9812 ID(and); SP(ss, rsrc); S2R(rdst); F__SZ_; 9813 9814 } 9815 break; 9816 } 9817 break; 9818 case 0x31: 9819 GETBYTE (); 9820 switch (op[2] & 0x00) 9821 { 9822 case 0x00: 9823 goto op_semantics_67; 9824 break; 9825 } 9826 break; 9827 case 0x32: 9828 GETBYTE (); 9829 switch (op[2] & 0x00) 9830 { 9831 case 0x00: 9832 goto op_semantics_67; 9833 break; 9834 } 9835 break; 9836 case 0x33: 9837 GETBYTE (); 9838 switch (op[2] & 0x00) 9839 { 9840 case 0x00: 9841 goto op_semantics_67; 9842 break; 9843 } 9844 break; 9845 case 0x34: 9846 GETBYTE (); 9847 switch (op[2] & 0x00) 9848 { 9849 case 0x00: 9850 op_semantics_68: 9851 { 9852 /** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */ 9853 #line 474 "rx-decode.opc" 9854 int ss AU = op[1] & 0x03; 9855 #line 474 "rx-decode.opc" 9856 int rsrc AU = (op[2] >> 4) & 0x0f; 9857 #line 474 "rx-decode.opc" 9858 int rdst AU = op[2] & 0x0f; 9859 if (trace) 9860 { 9861 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9862 "/** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */", 9863 op[0], op[1], op[2]); 9864 printf (" ss = 0x%x,", ss); 9865 printf (" rsrc = 0x%x,", rsrc); 9866 printf (" rdst = 0x%x\n", rdst); 9867 } 9868 SYNTAX("xor %1%S1, %0"); 9869 #line 474 "rx-decode.opc" 9870 ID(xor); SP(ss, rsrc); DR(rdst); F__SZ_; 9871 9872 } 9873 break; 9874 } 9875 break; 9876 case 0x35: 9877 GETBYTE (); 9878 switch (op[2] & 0x00) 9879 { 9880 case 0x00: 9881 goto op_semantics_68; 9882 break; 9883 } 9884 break; 9885 case 0x36: 9886 GETBYTE (); 9887 switch (op[2] & 0x00) 9888 { 9889 case 0x00: 9890 goto op_semantics_68; 9891 break; 9892 } 9893 break; 9894 case 0x37: 9895 GETBYTE (); 9896 switch (op[2] & 0x00) 9897 { 9898 case 0x00: 9899 goto op_semantics_68; 9900 break; 9901 } 9902 break; 9903 case 0x3b: 9904 GETBYTE (); 9905 switch (op[2] & 0x00) 9906 { 9907 case 0x00: 9908 { 9909 /** 1111 1100 0011 1011 rsrc rdst not %1, %0 */ 9910 #line 486 "rx-decode.opc" 9911 int rsrc AU = (op[2] >> 4) & 0x0f; 9912 #line 486 "rx-decode.opc" 9913 int rdst AU = op[2] & 0x0f; 9914 if (trace) 9915 { 9916 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9917 "/** 1111 1100 0011 1011 rsrc rdst not %1, %0 */", 9918 op[0], op[1], op[2]); 9919 printf (" rsrc = 0x%x,", rsrc); 9920 printf (" rdst = 0x%x\n", rdst); 9921 } 9922 SYNTAX("not %1, %0"); 9923 #line 486 "rx-decode.opc" 9924 ID(xor); DR(rdst); SR(rsrc); S2C(~0); F__SZ_; 9925 9926 /*----------------------------------------------------------------------*/ 9927 /* TST */ 9928 9929 } 9930 break; 9931 } 9932 break; 9933 case 0x40: 9934 GETBYTE (); 9935 switch (op[2] & 0x00) 9936 { 9937 case 0x00: 9938 op_semantics_69: 9939 { 9940 /** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */ 9941 #line 408 "rx-decode.opc" 9942 int ss AU = op[1] & 0x03; 9943 #line 408 "rx-decode.opc" 9944 int rsrc AU = (op[2] >> 4) & 0x0f; 9945 #line 408 "rx-decode.opc" 9946 int rdst AU = op[2] & 0x0f; 9947 if (trace) 9948 { 9949 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9950 "/** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */", 9951 op[0], op[1], op[2]); 9952 printf (" ss = 0x%x,", ss); 9953 printf (" rsrc = 0x%x,", rsrc); 9954 printf (" rdst = 0x%x\n", rdst); 9955 } 9956 SYNTAX("xchg %1%S1, %0"); 9957 #line 408 "rx-decode.opc" 9958 ID(xchg); DR(rdst); SP(ss, rsrc); 9959 9960 } 9961 break; 9962 } 9963 break; 9964 case 0x41: 9965 GETBYTE (); 9966 switch (op[2] & 0x00) 9967 { 9968 case 0x00: 9969 goto op_semantics_69; 9970 break; 9971 } 9972 break; 9973 case 0x42: 9974 GETBYTE (); 9975 switch (op[2] & 0x00) 9976 { 9977 case 0x00: 9978 goto op_semantics_69; 9979 break; 9980 } 9981 break; 9982 case 0x43: 9983 GETBYTE (); 9984 switch (op[2] & 0x00) 9985 { 9986 case 0x00: 9987 goto op_semantics_69; 9988 break; 9989 } 9990 break; 9991 case 0x44: 9992 GETBYTE (); 9993 switch (op[2] & 0x00) 9994 { 9995 case 0x00: 9996 op_semantics_70: 9997 { 9998 /** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */ 9999 #line 951 "rx-decode.opc" 10000 int sd AU = op[1] & 0x03; 10001 #line 951 "rx-decode.opc" 10002 int rsrc AU = (op[2] >> 4) & 0x0f; 10003 #line 951 "rx-decode.opc" 10004 int rdst AU = op[2] & 0x0f; 10005 if (trace) 10006 { 10007 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10008 "/** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */", 10009 op[0], op[1], op[2]); 10010 printf (" sd = 0x%x,", sd); 10011 printf (" rsrc = 0x%x,", rsrc); 10012 printf (" rdst = 0x%x\n", rdst); 10013 } 10014 SYNTAX("itof %1%S1, %0"); 10015 #line 951 "rx-decode.opc" 10016 ID(itof); DR (rdst); SP(sd, rsrc); F__SZ_; 10017 10018 } 10019 break; 10020 } 10021 break; 10022 case 0x45: 10023 GETBYTE (); 10024 switch (op[2] & 0x00) 10025 { 10026 case 0x00: 10027 goto op_semantics_70; 10028 break; 10029 } 10030 break; 10031 case 0x46: 10032 GETBYTE (); 10033 switch (op[2] & 0x00) 10034 { 10035 case 0x00: 10036 goto op_semantics_70; 10037 break; 10038 } 10039 break; 10040 case 0x47: 10041 GETBYTE (); 10042 switch (op[2] & 0x00) 10043 { 10044 case 0x00: 10045 goto op_semantics_70; 10046 break; 10047 } 10048 break; 10049 case 0x4b: 10050 GETBYTE (); 10051 switch (op[2] & 0x00) 10052 { 10053 case 0x00: 10054 { 10055 /** 1111 1100 0100 1011 rsrc rdst stz %1, %0 */ 10056 #line 1077 "rx-decode.opc" 10057 int rsrc AU = (op[2] >> 4) & 0x0f; 10058 #line 1077 "rx-decode.opc" 10059 int rdst AU = op[2] & 0x0f; 10060 if (trace) 10061 { 10062 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10063 "/** 1111 1100 0100 1011 rsrc rdst stz %1, %0 */", 10064 op[0], op[1], op[2]); 10065 printf (" rsrc = 0x%x,", rsrc); 10066 printf (" rdst = 0x%x\n", rdst); 10067 } 10068 SYNTAX("stz %1, %0"); 10069 #line 1077 "rx-decode.opc" 10070 ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_z); 10071 10072 } 10073 break; 10074 } 10075 break; 10076 case 0x4f: 10077 GETBYTE (); 10078 switch (op[2] & 0x00) 10079 { 10080 case 0x00: 10081 { 10082 /** 1111 1100 0100 1111 rsrc rdst stnz %1, %0 */ 10083 #line 1080 "rx-decode.opc" 10084 int rsrc AU = (op[2] >> 4) & 0x0f; 10085 #line 1080 "rx-decode.opc" 10086 int rdst AU = op[2] & 0x0f; 10087 if (trace) 10088 { 10089 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10090 "/** 1111 1100 0100 1111 rsrc rdst stnz %1, %0 */", 10091 op[0], op[1], op[2]); 10092 printf (" rsrc = 0x%x,", rsrc); 10093 printf (" rdst = 0x%x\n", rdst); 10094 } 10095 SYNTAX("stnz %1, %0"); 10096 #line 1080 "rx-decode.opc" 10097 ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_nz); 10098 10099 } 10100 break; 10101 } 10102 break; 10103 case 0x54: 10104 GETBYTE (); 10105 switch (op[2] & 0x00) 10106 { 10107 case 0x00: 10108 op_semantics_71: 10109 { 10110 /** 1111 1100 0101 01sd rsrc rdst utof %1%S1, %0 */ 10111 #line 1137 "rx-decode.opc" 10112 int sd AU = op[1] & 0x03; 10113 #line 1137 "rx-decode.opc" 10114 int rsrc AU = (op[2] >> 4) & 0x0f; 10115 #line 1137 "rx-decode.opc" 10116 int rdst AU = op[2] & 0x0f; 10117 if (trace) 10118 { 10119 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10120 "/** 1111 1100 0101 01sd rsrc rdst utof %1%S1, %0 */", 10121 op[0], op[1], op[2]); 10122 printf (" sd = 0x%x,", sd); 10123 printf (" rsrc = 0x%x,", rsrc); 10124 printf (" rdst = 0x%x\n", rdst); 10125 } 10126 SYNTAX("utof %1%S1, %0"); 10127 #line 1137 "rx-decode.opc" 10128 ID(utof); DR (rdst); SP(sd, rsrc); F__SZ_; 10129 10130 } 10131 break; 10132 } 10133 break; 10134 case 0x55: 10135 GETBYTE (); 10136 switch (op[2] & 0x00) 10137 { 10138 case 0x00: 10139 goto op_semantics_71; 10140 break; 10141 } 10142 break; 10143 case 0x56: 10144 GETBYTE (); 10145 switch (op[2] & 0x00) 10146 { 10147 case 0x00: 10148 goto op_semantics_71; 10149 break; 10150 } 10151 break; 10152 case 0x57: 10153 GETBYTE (); 10154 switch (op[2] & 0x00) 10155 { 10156 case 0x00: 10157 goto op_semantics_71; 10158 break; 10159 } 10160 break; 10161 case 0x5a: 10162 GETBYTE (); 10163 switch (op[2] & 0x00) 10164 { 10165 case 0x00: 10166 { 10167 /** 1111 1100 0101 1010 rsrc rdst bfmovz %bf */ 10168 #line 1152 "rx-decode.opc" 10169 int rsrc AU = (op[2] >> 4) & 0x0f; 10170 #line 1152 "rx-decode.opc" 10171 int rdst AU = op[2] & 0x0f; 10172 if (trace) 10173 { 10174 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10175 "/** 1111 1100 0101 1010 rsrc rdst bfmovz %bf */", 10176 op[0], op[1], op[2]); 10177 printf (" rsrc = 0x%x,", rsrc); 10178 printf (" rdst = 0x%x\n", rdst); 10179 } 10180 SYNTAX("bfmovz %bf"); 10181 #line 1152 "rx-decode.opc" 10182 ID(bfmovz); DR(rdst); SR(rsrc); S2C(IMM(2)); F_____; 10183 10184 } 10185 break; 10186 } 10187 break; 10188 case 0x5e: 10189 GETBYTE (); 10190 switch (op[2] & 0x00) 10191 { 10192 case 0x00: 10193 { 10194 /** 1111 1100 0101 1110 rsrc rdst bfmov %bf */ 10195 #line 1149 "rx-decode.opc" 10196 int rsrc AU = (op[2] >> 4) & 0x0f; 10197 #line 1149 "rx-decode.opc" 10198 int rdst AU = op[2] & 0x0f; 10199 if (trace) 10200 { 10201 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10202 "/** 1111 1100 0101 1110 rsrc rdst bfmov %bf */", 10203 op[0], op[1], op[2]); 10204 printf (" rsrc = 0x%x,", rsrc); 10205 printf (" rdst = 0x%x\n", rdst); 10206 } 10207 SYNTAX("bfmov %bf"); 10208 #line 1149 "rx-decode.opc" 10209 ID(bfmov); DR(rdst); SR(rsrc); S2C(IMM(2)); F_____; 10210 10211 } 10212 break; 10213 } 10214 break; 10215 case 0x60: 10216 GETBYTE (); 10217 switch (op[2] & 0x00) 10218 { 10219 case 0x00: 10220 op_semantics_72: 10221 { 10222 /** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */ 10223 #line 963 "rx-decode.opc" 10224 int sd AU = op[1] & 0x03; 10225 #line 963 "rx-decode.opc" 10226 int rdst AU = (op[2] >> 4) & 0x0f; 10227 #line 963 "rx-decode.opc" 10228 int rsrc AU = op[2] & 0x0f; 10229 if (trace) 10230 { 10231 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10232 "/** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */", 10233 op[0], op[1], op[2]); 10234 printf (" sd = 0x%x,", sd); 10235 printf (" rdst = 0x%x,", rdst); 10236 printf (" rsrc = 0x%x\n", rsrc); 10237 } 10238 SYNTAX("bset %1, %0%S0"); 10239 #line 963 "rx-decode.opc" 10240 ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____; 10241 if (sd == 3) /* bset reg,reg */ 10242 BWL(LSIZE); 10243 10244 } 10245 break; 10246 } 10247 break; 10248 case 0x61: 10249 GETBYTE (); 10250 switch (op[2] & 0x00) 10251 { 10252 case 0x00: 10253 goto op_semantics_72; 10254 break; 10255 } 10256 break; 10257 case 0x62: 10258 GETBYTE (); 10259 switch (op[2] & 0x00) 10260 { 10261 case 0x00: 10262 goto op_semantics_72; 10263 break; 10264 } 10265 break; 10266 case 0x63: 10267 GETBYTE (); 10268 switch (op[2] & 0x00) 10269 { 10270 case 0x00: 10271 goto op_semantics_72; 10272 break; 10273 } 10274 break; 10275 case 0x64: 10276 GETBYTE (); 10277 switch (op[2] & 0x00) 10278 { 10279 case 0x00: 10280 op_semantics_73: 10281 { 10282 /** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */ 10283 #line 975 "rx-decode.opc" 10284 int sd AU = op[1] & 0x03; 10285 #line 975 "rx-decode.opc" 10286 int rdst AU = (op[2] >> 4) & 0x0f; 10287 #line 975 "rx-decode.opc" 10288 int rsrc AU = op[2] & 0x0f; 10289 if (trace) 10290 { 10291 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10292 "/** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */", 10293 op[0], op[1], op[2]); 10294 printf (" sd = 0x%x,", sd); 10295 printf (" rdst = 0x%x,", rdst); 10296 printf (" rsrc = 0x%x\n", rsrc); 10297 } 10298 SYNTAX("bclr %1, %0%S0"); 10299 #line 975 "rx-decode.opc" 10300 ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____; 10301 if (sd == 3) /* bset reg,reg */ 10302 BWL(LSIZE); 10303 10304 } 10305 break; 10306 } 10307 break; 10308 case 0x65: 10309 GETBYTE (); 10310 switch (op[2] & 0x00) 10311 { 10312 case 0x00: 10313 goto op_semantics_73; 10314 break; 10315 } 10316 break; 10317 case 0x66: 10318 GETBYTE (); 10319 switch (op[2] & 0x00) 10320 { 10321 case 0x00: 10322 goto op_semantics_73; 10323 break; 10324 } 10325 break; 10326 case 0x67: 10327 GETBYTE (); 10328 switch (op[2] & 0x00) 10329 { 10330 case 0x00: 10331 goto op_semantics_73; 10332 break; 10333 } 10334 break; 10335 case 0x68: 10336 GETBYTE (); 10337 switch (op[2] & 0x00) 10338 { 10339 case 0x00: 10340 op_semantics_74: 10341 { 10342 /** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */ 10343 #line 987 "rx-decode.opc" 10344 int sd AU = op[1] & 0x03; 10345 #line 987 "rx-decode.opc" 10346 int rdst AU = (op[2] >> 4) & 0x0f; 10347 #line 987 "rx-decode.opc" 10348 int rsrc AU = op[2] & 0x0f; 10349 if (trace) 10350 { 10351 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10352 "/** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */", 10353 op[0], op[1], op[2]); 10354 printf (" sd = 0x%x,", sd); 10355 printf (" rdst = 0x%x,", rdst); 10356 printf (" rsrc = 0x%x\n", rsrc); 10357 } 10358 SYNTAX("btst %2, %1%S1"); 10359 #line 987 "rx-decode.opc" 10360 ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ZC; 10361 if (sd == 3) /* bset reg,reg */ 10362 BWL(LSIZE); 10363 10364 } 10365 break; 10366 } 10367 break; 10368 case 0x69: 10369 GETBYTE (); 10370 switch (op[2] & 0x00) 10371 { 10372 case 0x00: 10373 goto op_semantics_74; 10374 break; 10375 } 10376 break; 10377 case 0x6a: 10378 GETBYTE (); 10379 switch (op[2] & 0x00) 10380 { 10381 case 0x00: 10382 goto op_semantics_74; 10383 break; 10384 } 10385 break; 10386 case 0x6b: 10387 GETBYTE (); 10388 switch (op[2] & 0x00) 10389 { 10390 case 0x00: 10391 goto op_semantics_74; 10392 break; 10393 } 10394 break; 10395 case 0x6c: 10396 GETBYTE (); 10397 switch (op[2] & 0x00) 10398 { 10399 case 0x00: 10400 op_semantics_75: 10401 { 10402 /** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */ 10403 #line 999 "rx-decode.opc" 10404 int sd AU = op[1] & 0x03; 10405 #line 999 "rx-decode.opc" 10406 int rdst AU = (op[2] >> 4) & 0x0f; 10407 #line 999 "rx-decode.opc" 10408 int rsrc AU = op[2] & 0x0f; 10409 if (trace) 10410 { 10411 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10412 "/** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */", 10413 op[0], op[1], op[2]); 10414 printf (" sd = 0x%x,", sd); 10415 printf (" rdst = 0x%x,", rdst); 10416 printf (" rsrc = 0x%x\n", rsrc); 10417 } 10418 SYNTAX("bnot %1, %0%S0"); 10419 #line 999 "rx-decode.opc" 10420 ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); 10421 if (sd == 3) /* bset reg,reg */ 10422 BWL(LSIZE); 10423 10424 } 10425 break; 10426 } 10427 break; 10428 case 0x6d: 10429 GETBYTE (); 10430 switch (op[2] & 0x00) 10431 { 10432 case 0x00: 10433 goto op_semantics_75; 10434 break; 10435 } 10436 break; 10437 case 0x6e: 10438 GETBYTE (); 10439 switch (op[2] & 0x00) 10440 { 10441 case 0x00: 10442 goto op_semantics_75; 10443 break; 10444 } 10445 break; 10446 case 0x6f: 10447 GETBYTE (); 10448 switch (op[2] & 0x00) 10449 { 10450 case 0x00: 10451 goto op_semantics_75; 10452 break; 10453 } 10454 break; 10455 case 0x78: 10456 GETBYTE (); 10457 switch (op[2] & 0x0f) 10458 { 10459 case 0x08: 10460 op_semantics_76: 10461 { 10462 /** 1111 1100 0111 10sz rdst 1000 dmov.d %1, %0 */ 10463 #line 1185 "rx-decode.opc" 10464 int sz AU = op[1] & 0x03; 10465 #line 1185 "rx-decode.opc" 10466 int rdst AU = (op[2] >> 4) & 0x0f; 10467 if (trace) 10468 { 10469 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10470 "/** 1111 1100 0111 10sz rdst 1000 dmov.d %1, %0 */", 10471 op[0], op[1], op[2]); 10472 printf (" sz = 0x%x,", sz); 10473 printf (" rdst = 0x%x\n", rdst); 10474 } 10475 SYNTAX("dmov.d %1, %0"); 10476 #line 1185 "rx-decode.opc" 10477 int rsrc; 10478 rx_disp(0, sz, rdst, RX_Double, ld); 10479 rsrc = GETBYTE(); 10480 if (rsrc & 0x0f) 10481 UNSUPPORTED(); 10482 else { 10483 ID(dmov); SDR(rsrc >> 4); F_____; 10484 } 10485 10486 } 10487 break; 10488 default: UNSUPPORTED(); break; 10489 } 10490 break; 10491 case 0x79: 10492 GETBYTE (); 10493 switch (op[2] & 0x0f) 10494 { 10495 case 0x08: 10496 goto op_semantics_76; 10497 break; 10498 default: UNSUPPORTED(); break; 10499 } 10500 break; 10501 case 0x7a: 10502 GETBYTE (); 10503 switch (op[2] & 0x0f) 10504 { 10505 case 0x08: 10506 goto op_semantics_76; 10507 break; 10508 default: UNSUPPORTED(); break; 10509 } 10510 break; 10511 case 0x80: 10512 GETBYTE (); 10513 switch (op[2] & 0x00) 10514 { 10515 case 0x00: 10516 op_semantics_77: 10517 { 10518 /** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */ 10519 #line 930 "rx-decode.opc" 10520 int sd AU = op[1] & 0x03; 10521 #line 930 "rx-decode.opc" 10522 int rsrc AU = (op[2] >> 4) & 0x0f; 10523 #line 930 "rx-decode.opc" 10524 int rdst AU = op[2] & 0x0f; 10525 if (trace) 10526 { 10527 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10528 "/** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */", 10529 op[0], op[1], op[2]); 10530 printf (" sd = 0x%x,", sd); 10531 printf (" rsrc = 0x%x,", rsrc); 10532 printf (" rdst = 0x%x\n", rdst); 10533 } 10534 SYNTAX("fsub %1%S1, %0"); 10535 #line 930 "rx-decode.opc" 10536 ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 10537 10538 } 10539 break; 10540 } 10541 break; 10542 case 0x81: 10543 GETBYTE (); 10544 switch (op[2] & 0x00) 10545 { 10546 case 0x00: 10547 goto op_semantics_77; 10548 break; 10549 } 10550 break; 10551 case 0x82: 10552 GETBYTE (); 10553 switch (op[2] & 0x00) 10554 { 10555 case 0x00: 10556 goto op_semantics_77; 10557 break; 10558 } 10559 break; 10560 case 0x83: 10561 GETBYTE (); 10562 switch (op[2] & 0x00) 10563 { 10564 case 0x00: 10565 goto op_semantics_77; 10566 break; 10567 } 10568 break; 10569 case 0x84: 10570 GETBYTE (); 10571 switch (op[2] & 0x00) 10572 { 10573 case 0x00: 10574 op_semantics_78: 10575 { 10576 /** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */ 10577 #line 924 "rx-decode.opc" 10578 int sd AU = op[1] & 0x03; 10579 #line 924 "rx-decode.opc" 10580 int rsrc AU = (op[2] >> 4) & 0x0f; 10581 #line 924 "rx-decode.opc" 10582 int rdst AU = op[2] & 0x0f; 10583 if (trace) 10584 { 10585 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10586 "/** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */", 10587 op[0], op[1], op[2]); 10588 printf (" sd = 0x%x,", sd); 10589 printf (" rsrc = 0x%x,", rsrc); 10590 printf (" rdst = 0x%x\n", rdst); 10591 } 10592 SYNTAX("fcmp %1%S1, %0"); 10593 #line 924 "rx-decode.opc" 10594 ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F_OSZ_; 10595 10596 } 10597 break; 10598 } 10599 break; 10600 case 0x85: 10601 GETBYTE (); 10602 switch (op[2] & 0x00) 10603 { 10604 case 0x00: 10605 goto op_semantics_78; 10606 break; 10607 } 10608 break; 10609 case 0x86: 10610 GETBYTE (); 10611 switch (op[2] & 0x00) 10612 { 10613 case 0x00: 10614 goto op_semantics_78; 10615 break; 10616 } 10617 break; 10618 case 0x87: 10619 GETBYTE (); 10620 switch (op[2] & 0x00) 10621 { 10622 case 0x00: 10623 goto op_semantics_78; 10624 break; 10625 } 10626 break; 10627 case 0x88: 10628 GETBYTE (); 10629 switch (op[2] & 0x00) 10630 { 10631 case 0x00: 10632 op_semantics_79: 10633 { 10634 /** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */ 10635 #line 918 "rx-decode.opc" 10636 int sd AU = op[1] & 0x03; 10637 #line 918 "rx-decode.opc" 10638 int rsrc AU = (op[2] >> 4) & 0x0f; 10639 #line 918 "rx-decode.opc" 10640 int rdst AU = op[2] & 0x0f; 10641 if (trace) 10642 { 10643 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10644 "/** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */", 10645 op[0], op[1], op[2]); 10646 printf (" sd = 0x%x,", sd); 10647 printf (" rsrc = 0x%x,", rsrc); 10648 printf (" rdst = 0x%x\n", rdst); 10649 } 10650 SYNTAX("fadd %1%S1, %0"); 10651 #line 918 "rx-decode.opc" 10652 ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 10653 10654 } 10655 break; 10656 } 10657 break; 10658 case 0x89: 10659 GETBYTE (); 10660 switch (op[2] & 0x00) 10661 { 10662 case 0x00: 10663 goto op_semantics_79; 10664 break; 10665 } 10666 break; 10667 case 0x8a: 10668 GETBYTE (); 10669 switch (op[2] & 0x00) 10670 { 10671 case 0x00: 10672 goto op_semantics_79; 10673 break; 10674 } 10675 break; 10676 case 0x8b: 10677 GETBYTE (); 10678 switch (op[2] & 0x00) 10679 { 10680 case 0x00: 10681 goto op_semantics_79; 10682 break; 10683 } 10684 break; 10685 case 0x8c: 10686 GETBYTE (); 10687 switch (op[2] & 0x00) 10688 { 10689 case 0x00: 10690 op_semantics_80: 10691 { 10692 /** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */ 10693 #line 939 "rx-decode.opc" 10694 int sd AU = op[1] & 0x03; 10695 #line 939 "rx-decode.opc" 10696 int rsrc AU = (op[2] >> 4) & 0x0f; 10697 #line 939 "rx-decode.opc" 10698 int rdst AU = op[2] & 0x0f; 10699 if (trace) 10700 { 10701 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10702 "/** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */", 10703 op[0], op[1], op[2]); 10704 printf (" sd = 0x%x,", sd); 10705 printf (" rsrc = 0x%x,", rsrc); 10706 printf (" rdst = 0x%x\n", rdst); 10707 } 10708 SYNTAX("fmul %1%S1, %0"); 10709 #line 939 "rx-decode.opc" 10710 ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 10711 10712 } 10713 break; 10714 } 10715 break; 10716 case 0x8d: 10717 GETBYTE (); 10718 switch (op[2] & 0x00) 10719 { 10720 case 0x00: 10721 goto op_semantics_80; 10722 break; 10723 } 10724 break; 10725 case 0x8e: 10726 GETBYTE (); 10727 switch (op[2] & 0x00) 10728 { 10729 case 0x00: 10730 goto op_semantics_80; 10731 break; 10732 } 10733 break; 10734 case 0x8f: 10735 GETBYTE (); 10736 switch (op[2] & 0x00) 10737 { 10738 case 0x00: 10739 goto op_semantics_80; 10740 break; 10741 } 10742 break; 10743 case 0x90: 10744 GETBYTE (); 10745 switch (op[2] & 0x00) 10746 { 10747 case 0x00: 10748 op_semantics_81: 10749 { 10750 /** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */ 10751 #line 945 "rx-decode.opc" 10752 int sd AU = op[1] & 0x03; 10753 #line 945 "rx-decode.opc" 10754 int rsrc AU = (op[2] >> 4) & 0x0f; 10755 #line 945 "rx-decode.opc" 10756 int rdst AU = op[2] & 0x0f; 10757 if (trace) 10758 { 10759 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10760 "/** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */", 10761 op[0], op[1], op[2]); 10762 printf (" sd = 0x%x,", sd); 10763 printf (" rsrc = 0x%x,", rsrc); 10764 printf (" rdst = 0x%x\n", rdst); 10765 } 10766 SYNTAX("fdiv %1%S1, %0"); 10767 #line 945 "rx-decode.opc" 10768 ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 10769 10770 } 10771 break; 10772 } 10773 break; 10774 case 0x91: 10775 GETBYTE (); 10776 switch (op[2] & 0x00) 10777 { 10778 case 0x00: 10779 goto op_semantics_81; 10780 break; 10781 } 10782 break; 10783 case 0x92: 10784 GETBYTE (); 10785 switch (op[2] & 0x00) 10786 { 10787 case 0x00: 10788 goto op_semantics_81; 10789 break; 10790 } 10791 break; 10792 case 0x93: 10793 GETBYTE (); 10794 switch (op[2] & 0x00) 10795 { 10796 case 0x00: 10797 goto op_semantics_81; 10798 break; 10799 } 10800 break; 10801 case 0x94: 10802 GETBYTE (); 10803 switch (op[2] & 0x00) 10804 { 10805 case 0x00: 10806 op_semantics_82: 10807 { 10808 /** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */ 10809 #line 933 "rx-decode.opc" 10810 int sd AU = op[1] & 0x03; 10811 #line 933 "rx-decode.opc" 10812 int rsrc AU = (op[2] >> 4) & 0x0f; 10813 #line 933 "rx-decode.opc" 10814 int rdst AU = op[2] & 0x0f; 10815 if (trace) 10816 { 10817 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10818 "/** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */", 10819 op[0], op[1], op[2]); 10820 printf (" sd = 0x%x,", sd); 10821 printf (" rsrc = 0x%x,", rsrc); 10822 printf (" rdst = 0x%x\n", rdst); 10823 } 10824 SYNTAX("ftoi %1%S1, %0"); 10825 #line 933 "rx-decode.opc" 10826 ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 10827 10828 } 10829 break; 10830 } 10831 break; 10832 case 0x95: 10833 GETBYTE (); 10834 switch (op[2] & 0x00) 10835 { 10836 case 0x00: 10837 goto op_semantics_82; 10838 break; 10839 } 10840 break; 10841 case 0x96: 10842 GETBYTE (); 10843 switch (op[2] & 0x00) 10844 { 10845 case 0x00: 10846 goto op_semantics_82; 10847 break; 10848 } 10849 break; 10850 case 0x97: 10851 GETBYTE (); 10852 switch (op[2] & 0x00) 10853 { 10854 case 0x00: 10855 goto op_semantics_82; 10856 break; 10857 } 10858 break; 10859 case 0x98: 10860 GETBYTE (); 10861 switch (op[2] & 0x00) 10862 { 10863 case 0x00: 10864 op_semantics_83: 10865 { 10866 /** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */ 10867 #line 948 "rx-decode.opc" 10868 int sd AU = op[1] & 0x03; 10869 #line 948 "rx-decode.opc" 10870 int rsrc AU = (op[2] >> 4) & 0x0f; 10871 #line 948 "rx-decode.opc" 10872 int rdst AU = op[2] & 0x0f; 10873 if (trace) 10874 { 10875 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10876 "/** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */", 10877 op[0], op[1], op[2]); 10878 printf (" sd = 0x%x,", sd); 10879 printf (" rsrc = 0x%x,", rsrc); 10880 printf (" rdst = 0x%x\n", rdst); 10881 } 10882 SYNTAX("round %1%S1, %0"); 10883 #line 948 "rx-decode.opc" 10884 ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 10885 10886 } 10887 break; 10888 } 10889 break; 10890 case 0x99: 10891 GETBYTE (); 10892 switch (op[2] & 0x00) 10893 { 10894 case 0x00: 10895 goto op_semantics_83; 10896 break; 10897 } 10898 break; 10899 case 0x9a: 10900 GETBYTE (); 10901 switch (op[2] & 0x00) 10902 { 10903 case 0x00: 10904 goto op_semantics_83; 10905 break; 10906 } 10907 break; 10908 case 0x9b: 10909 GETBYTE (); 10910 switch (op[2] & 0x00) 10911 { 10912 case 0x00: 10913 goto op_semantics_83; 10914 break; 10915 } 10916 break; 10917 case 0xa0: 10918 GETBYTE (); 10919 switch (op[2] & 0x00) 10920 { 10921 case 0x00: 10922 op_semantics_84: 10923 { 10924 /** 1111 1100 1010 00sd rsrc rdst fsqrt %1%S1, %0 */ 10925 #line 1131 "rx-decode.opc" 10926 int sd AU = op[1] & 0x03; 10927 #line 1131 "rx-decode.opc" 10928 int rsrc AU = (op[2] >> 4) & 0x0f; 10929 #line 1131 "rx-decode.opc" 10930 int rdst AU = op[2] & 0x0f; 10931 if (trace) 10932 { 10933 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10934 "/** 1111 1100 1010 00sd rsrc rdst fsqrt %1%S1, %0 */", 10935 op[0], op[1], op[2]); 10936 printf (" sd = 0x%x,", sd); 10937 printf (" rsrc = 0x%x,", rsrc); 10938 printf (" rdst = 0x%x\n", rdst); 10939 } 10940 SYNTAX("fsqrt %1%S1, %0"); 10941 #line 1131 "rx-decode.opc" 10942 ID(fsqrt); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 10943 10944 } 10945 break; 10946 } 10947 break; 10948 case 0xa1: 10949 GETBYTE (); 10950 switch (op[2] & 0x00) 10951 { 10952 case 0x00: 10953 goto op_semantics_84; 10954 break; 10955 } 10956 break; 10957 case 0xa2: 10958 GETBYTE (); 10959 switch (op[2] & 0x00) 10960 { 10961 case 0x00: 10962 goto op_semantics_84; 10963 break; 10964 } 10965 break; 10966 case 0xa3: 10967 GETBYTE (); 10968 switch (op[2] & 0x00) 10969 { 10970 case 0x00: 10971 goto op_semantics_84; 10972 break; 10973 } 10974 break; 10975 case 0xa4: 10976 GETBYTE (); 10977 switch (op[2] & 0x00) 10978 { 10979 case 0x00: 10980 op_semantics_85: 10981 { 10982 /** 1111 1100 1010 01sd rsrc rdst ftou %1%S1, %0 */ 10983 #line 1134 "rx-decode.opc" 10984 int sd AU = op[1] & 0x03; 10985 #line 1134 "rx-decode.opc" 10986 int rsrc AU = (op[2] >> 4) & 0x0f; 10987 #line 1134 "rx-decode.opc" 10988 int rdst AU = op[2] & 0x0f; 10989 if (trace) 10990 { 10991 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10992 "/** 1111 1100 1010 01sd rsrc rdst ftou %1%S1, %0 */", 10993 op[0], op[1], op[2]); 10994 printf (" sd = 0x%x,", sd); 10995 printf (" rsrc = 0x%x,", rsrc); 10996 printf (" rdst = 0x%x\n", rdst); 10997 } 10998 SYNTAX("ftou %1%S1, %0"); 10999 #line 1134 "rx-decode.opc" 11000 ID(ftou); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 11001 11002 } 11003 break; 11004 } 11005 break; 11006 case 0xa5: 11007 GETBYTE (); 11008 switch (op[2] & 0x00) 11009 { 11010 case 0x00: 11011 goto op_semantics_85; 11012 break; 11013 } 11014 break; 11015 case 0xa6: 11016 GETBYTE (); 11017 switch (op[2] & 0x00) 11018 { 11019 case 0x00: 11020 goto op_semantics_85; 11021 break; 11022 } 11023 break; 11024 case 0xa7: 11025 GETBYTE (); 11026 switch (op[2] & 0x00) 11027 { 11028 case 0x00: 11029 goto op_semantics_85; 11030 break; 11031 } 11032 break; 11033 case 0xc8: 11034 GETBYTE (); 11035 switch (op[2] & 0x0f) 11036 { 11037 case 0x08: 11038 op_semantics_86: 11039 { 11040 /** 1111 1100 1100 10sz rsrc 1000 dmov.d %1, %0 */ 11041 #line 1198 "rx-decode.opc" 11042 int sz AU = op[1] & 0x03; 11043 #line 1198 "rx-decode.opc" 11044 int rsrc AU = (op[2] >> 4) & 0x0f; 11045 if (trace) 11046 { 11047 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11048 "/** 1111 1100 1100 10sz rsrc 1000 dmov.d %1, %0 */", 11049 op[0], op[1], op[2]); 11050 printf (" sz = 0x%x,", sz); 11051 printf (" rsrc = 0x%x\n", rsrc); 11052 } 11053 SYNTAX("dmov.d %1, %0"); 11054 #line 1198 "rx-decode.opc" 11055 int rdst; 11056 rx_disp(1, sz, rsrc, RX_Double, ld); 11057 rdst = GETBYTE(); 11058 if (rdst & 0x0f) 11059 UNSUPPORTED(); 11060 else { 11061 ID(dmov); DDR(rdst >> 4); F_____; 11062 } 11063 11064 } 11065 break; 11066 default: UNSUPPORTED(); break; 11067 } 11068 break; 11069 case 0xc9: 11070 GETBYTE (); 11071 switch (op[2] & 0x0f) 11072 { 11073 case 0x08: 11074 goto op_semantics_86; 11075 break; 11076 default: UNSUPPORTED(); break; 11077 } 11078 break; 11079 case 0xca: 11080 GETBYTE (); 11081 switch (op[2] & 0x0f) 11082 { 11083 case 0x08: 11084 goto op_semantics_86; 11085 break; 11086 default: UNSUPPORTED(); break; 11087 } 11088 break; 11089 case 0xd0: 11090 GETBYTE (); 11091 switch (op[2] & 0x00) 11092 { 11093 case 0x00: 11094 op_semantics_87: 11095 { 11096 /** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */ 11097 #line 1065 "rx-decode.opc" 11098 int sz AU = (op[1] >> 2) & 0x03; 11099 #line 1065 "rx-decode.opc" 11100 int sd AU = op[1] & 0x03; 11101 #line 1065 "rx-decode.opc" 11102 int rdst AU = (op[2] >> 4) & 0x0f; 11103 #line 1065 "rx-decode.opc" 11104 int cond AU = op[2] & 0x0f; 11105 if (trace) 11106 { 11107 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11108 "/** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */", 11109 op[0], op[1], op[2]); 11110 printf (" sz = 0x%x,", sz); 11111 printf (" sd = 0x%x,", sd); 11112 printf (" rdst = 0x%x,", rdst); 11113 printf (" cond = 0x%x\n", cond); 11114 } 11115 SYNTAX("sc%1%s %0"); 11116 #line 1065 "rx-decode.opc" 11117 ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond); 11118 11119 /*----------------------------------------------------------------------*/ 11120 /* RXv2 enhanced */ 11121 11122 } 11123 break; 11124 } 11125 break; 11126 case 0xd1: 11127 GETBYTE (); 11128 switch (op[2] & 0x00) 11129 { 11130 case 0x00: 11131 goto op_semantics_87; 11132 break; 11133 } 11134 break; 11135 case 0xd2: 11136 GETBYTE (); 11137 switch (op[2] & 0x00) 11138 { 11139 case 0x00: 11140 goto op_semantics_87; 11141 break; 11142 } 11143 break; 11144 case 0xd3: 11145 GETBYTE (); 11146 switch (op[2] & 0x00) 11147 { 11148 case 0x00: 11149 goto op_semantics_87; 11150 break; 11151 } 11152 break; 11153 case 0xd4: 11154 GETBYTE (); 11155 switch (op[2] & 0x00) 11156 { 11157 case 0x00: 11158 goto op_semantics_87; 11159 break; 11160 } 11161 break; 11162 case 0xd5: 11163 GETBYTE (); 11164 switch (op[2] & 0x00) 11165 { 11166 case 0x00: 11167 goto op_semantics_87; 11168 break; 11169 } 11170 break; 11171 case 0xd6: 11172 GETBYTE (); 11173 switch (op[2] & 0x00) 11174 { 11175 case 0x00: 11176 goto op_semantics_87; 11177 break; 11178 } 11179 break; 11180 case 0xd7: 11181 GETBYTE (); 11182 switch (op[2] & 0x00) 11183 { 11184 case 0x00: 11185 goto op_semantics_87; 11186 break; 11187 } 11188 break; 11189 case 0xd8: 11190 GETBYTE (); 11191 switch (op[2] & 0x00) 11192 { 11193 case 0x00: 11194 goto op_semantics_87; 11195 break; 11196 } 11197 break; 11198 case 0xd9: 11199 GETBYTE (); 11200 switch (op[2] & 0x00) 11201 { 11202 case 0x00: 11203 goto op_semantics_87; 11204 break; 11205 } 11206 break; 11207 case 0xda: 11208 GETBYTE (); 11209 switch (op[2] & 0x00) 11210 { 11211 case 0x00: 11212 goto op_semantics_87; 11213 break; 11214 } 11215 break; 11216 case 0xdb: 11217 GETBYTE (); 11218 switch (op[2] & 0x00) 11219 { 11220 case 0x00: 11221 goto op_semantics_87; 11222 break; 11223 } 11224 break; 11225 case 0xe0: 11226 GETBYTE (); 11227 switch (op[2] & 0x0f) 11228 { 11229 case 0x00: 11230 case 0x01: 11231 case 0x02: 11232 case 0x03: 11233 case 0x04: 11234 case 0x05: 11235 case 0x06: 11236 case 0x07: 11237 case 0x08: 11238 case 0x09: 11239 case 0x0a: 11240 case 0x0b: 11241 case 0x0c: 11242 case 0x0d: 11243 case 0x0e: 11244 op_semantics_88: 11245 { 11246 /** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */ 11247 #line 1008 "rx-decode.opc" 11248 int bit AU = (op[1] >> 2) & 0x07; 11249 #line 1008 "rx-decode.opc" 11250 int sd AU = op[1] & 0x03; 11251 #line 1008 "rx-decode.opc" 11252 int rdst AU = (op[2] >> 4) & 0x0f; 11253 #line 1008 "rx-decode.opc" 11254 int cond AU = op[2] & 0x0f; 11255 if (trace) 11256 { 11257 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11258 "/** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */", 11259 op[0], op[1], op[2]); 11260 printf (" bit = 0x%x,", bit); 11261 printf (" sd = 0x%x,", sd); 11262 printf (" rdst = 0x%x,", rdst); 11263 printf (" cond = 0x%x\n", cond); 11264 } 11265 SYNTAX("bm%2 #%1, %0%S0"); 11266 #line 1008 "rx-decode.opc" 11267 ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE); 11268 11269 } 11270 break; 11271 case 0x0f: 11272 op_semantics_89: 11273 { 11274 /** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */ 11275 #line 996 "rx-decode.opc" 11276 int bit AU = (op[1] >> 2) & 0x07; 11277 #line 996 "rx-decode.opc" 11278 int sd AU = op[1] & 0x03; 11279 #line 996 "rx-decode.opc" 11280 int rdst AU = (op[2] >> 4) & 0x0f; 11281 if (trace) 11282 { 11283 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11284 "/** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */", 11285 op[0], op[1], op[2]); 11286 printf (" bit = 0x%x,", bit); 11287 printf (" sd = 0x%x,", sd); 11288 printf (" rdst = 0x%x\n", rdst); 11289 } 11290 SYNTAX("bnot #%1, %0%S0"); 11291 #line 996 "rx-decode.opc" 11292 ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); 11293 11294 } 11295 break; 11296 } 11297 break; 11298 case 0xe1: 11299 GETBYTE (); 11300 switch (op[2] & 0x0f) 11301 { 11302 case 0x00: 11303 case 0x01: 11304 case 0x02: 11305 case 0x03: 11306 case 0x04: 11307 case 0x05: 11308 case 0x06: 11309 case 0x07: 11310 case 0x08: 11311 case 0x09: 11312 case 0x0a: 11313 case 0x0b: 11314 case 0x0c: 11315 case 0x0d: 11316 case 0x0e: 11317 goto op_semantics_88; 11318 break; 11319 case 0x0f: 11320 goto op_semantics_89; 11321 break; 11322 } 11323 break; 11324 case 0xe2: 11325 GETBYTE (); 11326 switch (op[2] & 0x0f) 11327 { 11328 case 0x00: 11329 case 0x01: 11330 case 0x02: 11331 case 0x03: 11332 case 0x04: 11333 case 0x05: 11334 case 0x06: 11335 case 0x07: 11336 case 0x08: 11337 case 0x09: 11338 case 0x0a: 11339 case 0x0b: 11340 case 0x0c: 11341 case 0x0d: 11342 case 0x0e: 11343 goto op_semantics_88; 11344 break; 11345 case 0x0f: 11346 goto op_semantics_89; 11347 break; 11348 } 11349 break; 11350 case 0xe3: 11351 GETBYTE (); 11352 switch (op[2] & 0x0f) 11353 { 11354 case 0x00: 11355 case 0x01: 11356 case 0x02: 11357 case 0x03: 11358 case 0x04: 11359 case 0x05: 11360 case 0x06: 11361 case 0x07: 11362 case 0x08: 11363 case 0x09: 11364 case 0x0a: 11365 case 0x0b: 11366 case 0x0c: 11367 case 0x0d: 11368 case 0x0e: 11369 goto op_semantics_88; 11370 break; 11371 case 0x0f: 11372 goto op_semantics_89; 11373 break; 11374 } 11375 break; 11376 case 0xe4: 11377 GETBYTE (); 11378 switch (op[2] & 0x0f) 11379 { 11380 case 0x00: 11381 case 0x01: 11382 case 0x02: 11383 case 0x03: 11384 case 0x04: 11385 case 0x05: 11386 case 0x06: 11387 case 0x07: 11388 case 0x08: 11389 case 0x09: 11390 case 0x0a: 11391 case 0x0b: 11392 case 0x0c: 11393 case 0x0d: 11394 case 0x0e: 11395 goto op_semantics_88; 11396 break; 11397 case 0x0f: 11398 goto op_semantics_89; 11399 break; 11400 } 11401 break; 11402 case 0xe5: 11403 GETBYTE (); 11404 switch (op[2] & 0x0f) 11405 { 11406 case 0x00: 11407 case 0x01: 11408 case 0x02: 11409 case 0x03: 11410 case 0x04: 11411 case 0x05: 11412 case 0x06: 11413 case 0x07: 11414 case 0x08: 11415 case 0x09: 11416 case 0x0a: 11417 case 0x0b: 11418 case 0x0c: 11419 case 0x0d: 11420 case 0x0e: 11421 goto op_semantics_88; 11422 break; 11423 case 0x0f: 11424 goto op_semantics_89; 11425 break; 11426 } 11427 break; 11428 case 0xe6: 11429 GETBYTE (); 11430 switch (op[2] & 0x0f) 11431 { 11432 case 0x00: 11433 case 0x01: 11434 case 0x02: 11435 case 0x03: 11436 case 0x04: 11437 case 0x05: 11438 case 0x06: 11439 case 0x07: 11440 case 0x08: 11441 case 0x09: 11442 case 0x0a: 11443 case 0x0b: 11444 case 0x0c: 11445 case 0x0d: 11446 case 0x0e: 11447 goto op_semantics_88; 11448 break; 11449 case 0x0f: 11450 goto op_semantics_89; 11451 break; 11452 } 11453 break; 11454 case 0xe7: 11455 GETBYTE (); 11456 switch (op[2] & 0x0f) 11457 { 11458 case 0x00: 11459 case 0x01: 11460 case 0x02: 11461 case 0x03: 11462 case 0x04: 11463 case 0x05: 11464 case 0x06: 11465 case 0x07: 11466 case 0x08: 11467 case 0x09: 11468 case 0x0a: 11469 case 0x0b: 11470 case 0x0c: 11471 case 0x0d: 11472 case 0x0e: 11473 goto op_semantics_88; 11474 break; 11475 case 0x0f: 11476 goto op_semantics_89; 11477 break; 11478 } 11479 break; 11480 case 0xe8: 11481 GETBYTE (); 11482 switch (op[2] & 0x0f) 11483 { 11484 case 0x00: 11485 case 0x01: 11486 case 0x02: 11487 case 0x03: 11488 case 0x04: 11489 case 0x05: 11490 case 0x06: 11491 case 0x07: 11492 case 0x08: 11493 case 0x09: 11494 case 0x0a: 11495 case 0x0b: 11496 case 0x0c: 11497 case 0x0d: 11498 case 0x0e: 11499 goto op_semantics_88; 11500 break; 11501 case 0x0f: 11502 goto op_semantics_89; 11503 break; 11504 } 11505 break; 11506 case 0xe9: 11507 GETBYTE (); 11508 switch (op[2] & 0x0f) 11509 { 11510 case 0x00: 11511 case 0x01: 11512 case 0x02: 11513 case 0x03: 11514 case 0x04: 11515 case 0x05: 11516 case 0x06: 11517 case 0x07: 11518 case 0x08: 11519 case 0x09: 11520 case 0x0a: 11521 case 0x0b: 11522 case 0x0c: 11523 case 0x0d: 11524 case 0x0e: 11525 goto op_semantics_88; 11526 break; 11527 case 0x0f: 11528 goto op_semantics_89; 11529 break; 11530 } 11531 break; 11532 case 0xea: 11533 GETBYTE (); 11534 switch (op[2] & 0x0f) 11535 { 11536 case 0x00: 11537 case 0x01: 11538 case 0x02: 11539 case 0x03: 11540 case 0x04: 11541 case 0x05: 11542 case 0x06: 11543 case 0x07: 11544 case 0x08: 11545 case 0x09: 11546 case 0x0a: 11547 case 0x0b: 11548 case 0x0c: 11549 case 0x0d: 11550 case 0x0e: 11551 goto op_semantics_88; 11552 break; 11553 case 0x0f: 11554 goto op_semantics_89; 11555 break; 11556 } 11557 break; 11558 case 0xeb: 11559 GETBYTE (); 11560 switch (op[2] & 0x0f) 11561 { 11562 case 0x00: 11563 case 0x01: 11564 case 0x02: 11565 case 0x03: 11566 case 0x04: 11567 case 0x05: 11568 case 0x06: 11569 case 0x07: 11570 case 0x08: 11571 case 0x09: 11572 case 0x0a: 11573 case 0x0b: 11574 case 0x0c: 11575 case 0x0d: 11576 case 0x0e: 11577 goto op_semantics_88; 11578 break; 11579 case 0x0f: 11580 goto op_semantics_89; 11581 break; 11582 } 11583 break; 11584 case 0xec: 11585 GETBYTE (); 11586 switch (op[2] & 0x0f) 11587 { 11588 case 0x00: 11589 case 0x01: 11590 case 0x02: 11591 case 0x03: 11592 case 0x04: 11593 case 0x05: 11594 case 0x06: 11595 case 0x07: 11596 case 0x08: 11597 case 0x09: 11598 case 0x0a: 11599 case 0x0b: 11600 case 0x0c: 11601 case 0x0d: 11602 case 0x0e: 11603 goto op_semantics_88; 11604 break; 11605 case 0x0f: 11606 goto op_semantics_89; 11607 break; 11608 } 11609 break; 11610 case 0xed: 11611 GETBYTE (); 11612 switch (op[2] & 0x0f) 11613 { 11614 case 0x00: 11615 case 0x01: 11616 case 0x02: 11617 case 0x03: 11618 case 0x04: 11619 case 0x05: 11620 case 0x06: 11621 case 0x07: 11622 case 0x08: 11623 case 0x09: 11624 case 0x0a: 11625 case 0x0b: 11626 case 0x0c: 11627 case 0x0d: 11628 case 0x0e: 11629 goto op_semantics_88; 11630 break; 11631 case 0x0f: 11632 goto op_semantics_89; 11633 break; 11634 } 11635 break; 11636 case 0xee: 11637 GETBYTE (); 11638 switch (op[2] & 0x0f) 11639 { 11640 case 0x00: 11641 case 0x01: 11642 case 0x02: 11643 case 0x03: 11644 case 0x04: 11645 case 0x05: 11646 case 0x06: 11647 case 0x07: 11648 case 0x08: 11649 case 0x09: 11650 case 0x0a: 11651 case 0x0b: 11652 case 0x0c: 11653 case 0x0d: 11654 case 0x0e: 11655 goto op_semantics_88; 11656 break; 11657 case 0x0f: 11658 goto op_semantics_89; 11659 break; 11660 } 11661 break; 11662 case 0xef: 11663 GETBYTE (); 11664 switch (op[2] & 0x0f) 11665 { 11666 case 0x00: 11667 case 0x01: 11668 case 0x02: 11669 case 0x03: 11670 case 0x04: 11671 case 0x05: 11672 case 0x06: 11673 case 0x07: 11674 case 0x08: 11675 case 0x09: 11676 case 0x0a: 11677 case 0x0b: 11678 case 0x0c: 11679 case 0x0d: 11680 case 0x0e: 11681 goto op_semantics_88; 11682 break; 11683 case 0x0f: 11684 goto op_semantics_89; 11685 break; 11686 } 11687 break; 11688 case 0xf0: 11689 GETBYTE (); 11690 switch (op[2] & 0x0f) 11691 { 11692 case 0x00: 11693 case 0x01: 11694 case 0x02: 11695 case 0x03: 11696 case 0x04: 11697 case 0x05: 11698 case 0x06: 11699 case 0x07: 11700 case 0x08: 11701 case 0x09: 11702 case 0x0a: 11703 case 0x0b: 11704 case 0x0c: 11705 case 0x0d: 11706 case 0x0e: 11707 goto op_semantics_88; 11708 break; 11709 case 0x0f: 11710 goto op_semantics_89; 11711 break; 11712 } 11713 break; 11714 case 0xf1: 11715 GETBYTE (); 11716 switch (op[2] & 0x0f) 11717 { 11718 case 0x00: 11719 case 0x01: 11720 case 0x02: 11721 case 0x03: 11722 case 0x04: 11723 case 0x05: 11724 case 0x06: 11725 case 0x07: 11726 case 0x08: 11727 case 0x09: 11728 case 0x0a: 11729 case 0x0b: 11730 case 0x0c: 11731 case 0x0d: 11732 case 0x0e: 11733 goto op_semantics_88; 11734 break; 11735 case 0x0f: 11736 goto op_semantics_89; 11737 break; 11738 } 11739 break; 11740 case 0xf2: 11741 GETBYTE (); 11742 switch (op[2] & 0x0f) 11743 { 11744 case 0x00: 11745 case 0x01: 11746 case 0x02: 11747 case 0x03: 11748 case 0x04: 11749 case 0x05: 11750 case 0x06: 11751 case 0x07: 11752 case 0x08: 11753 case 0x09: 11754 case 0x0a: 11755 case 0x0b: 11756 case 0x0c: 11757 case 0x0d: 11758 case 0x0e: 11759 goto op_semantics_88; 11760 break; 11761 case 0x0f: 11762 goto op_semantics_89; 11763 break; 11764 } 11765 break; 11766 case 0xf3: 11767 GETBYTE (); 11768 switch (op[2] & 0x0f) 11769 { 11770 case 0x00: 11771 case 0x01: 11772 case 0x02: 11773 case 0x03: 11774 case 0x04: 11775 case 0x05: 11776 case 0x06: 11777 case 0x07: 11778 case 0x08: 11779 case 0x09: 11780 case 0x0a: 11781 case 0x0b: 11782 case 0x0c: 11783 case 0x0d: 11784 case 0x0e: 11785 goto op_semantics_88; 11786 break; 11787 case 0x0f: 11788 goto op_semantics_89; 11789 break; 11790 } 11791 break; 11792 case 0xf4: 11793 GETBYTE (); 11794 switch (op[2] & 0x0f) 11795 { 11796 case 0x00: 11797 case 0x01: 11798 case 0x02: 11799 case 0x03: 11800 case 0x04: 11801 case 0x05: 11802 case 0x06: 11803 case 0x07: 11804 case 0x08: 11805 case 0x09: 11806 case 0x0a: 11807 case 0x0b: 11808 case 0x0c: 11809 case 0x0d: 11810 case 0x0e: 11811 goto op_semantics_88; 11812 break; 11813 case 0x0f: 11814 goto op_semantics_89; 11815 break; 11816 } 11817 break; 11818 case 0xf5: 11819 GETBYTE (); 11820 switch (op[2] & 0x0f) 11821 { 11822 case 0x00: 11823 case 0x01: 11824 case 0x02: 11825 case 0x03: 11826 case 0x04: 11827 case 0x05: 11828 case 0x06: 11829 case 0x07: 11830 case 0x08: 11831 case 0x09: 11832 case 0x0a: 11833 case 0x0b: 11834 case 0x0c: 11835 case 0x0d: 11836 case 0x0e: 11837 goto op_semantics_88; 11838 break; 11839 case 0x0f: 11840 goto op_semantics_89; 11841 break; 11842 } 11843 break; 11844 case 0xf6: 11845 GETBYTE (); 11846 switch (op[2] & 0x0f) 11847 { 11848 case 0x00: 11849 case 0x01: 11850 case 0x02: 11851 case 0x03: 11852 case 0x04: 11853 case 0x05: 11854 case 0x06: 11855 case 0x07: 11856 case 0x08: 11857 case 0x09: 11858 case 0x0a: 11859 case 0x0b: 11860 case 0x0c: 11861 case 0x0d: 11862 case 0x0e: 11863 goto op_semantics_88; 11864 break; 11865 case 0x0f: 11866 goto op_semantics_89; 11867 break; 11868 } 11869 break; 11870 case 0xf7: 11871 GETBYTE (); 11872 switch (op[2] & 0x0f) 11873 { 11874 case 0x00: 11875 case 0x01: 11876 case 0x02: 11877 case 0x03: 11878 case 0x04: 11879 case 0x05: 11880 case 0x06: 11881 case 0x07: 11882 case 0x08: 11883 case 0x09: 11884 case 0x0a: 11885 case 0x0b: 11886 case 0x0c: 11887 case 0x0d: 11888 case 0x0e: 11889 goto op_semantics_88; 11890 break; 11891 case 0x0f: 11892 goto op_semantics_89; 11893 break; 11894 } 11895 break; 11896 case 0xf8: 11897 GETBYTE (); 11898 switch (op[2] & 0x0f) 11899 { 11900 case 0x00: 11901 case 0x01: 11902 case 0x02: 11903 case 0x03: 11904 case 0x04: 11905 case 0x05: 11906 case 0x06: 11907 case 0x07: 11908 case 0x08: 11909 case 0x09: 11910 case 0x0a: 11911 case 0x0b: 11912 case 0x0c: 11913 case 0x0d: 11914 case 0x0e: 11915 goto op_semantics_88; 11916 break; 11917 case 0x0f: 11918 goto op_semantics_89; 11919 break; 11920 } 11921 break; 11922 case 0xf9: 11923 GETBYTE (); 11924 switch (op[2] & 0x0f) 11925 { 11926 case 0x00: 11927 case 0x01: 11928 case 0x02: 11929 case 0x03: 11930 case 0x04: 11931 case 0x05: 11932 case 0x06: 11933 case 0x07: 11934 case 0x08: 11935 case 0x09: 11936 case 0x0a: 11937 case 0x0b: 11938 case 0x0c: 11939 case 0x0d: 11940 case 0x0e: 11941 goto op_semantics_88; 11942 break; 11943 case 0x0f: 11944 goto op_semantics_89; 11945 break; 11946 } 11947 break; 11948 case 0xfa: 11949 GETBYTE (); 11950 switch (op[2] & 0x0f) 11951 { 11952 case 0x00: 11953 case 0x01: 11954 case 0x02: 11955 case 0x03: 11956 case 0x04: 11957 case 0x05: 11958 case 0x06: 11959 case 0x07: 11960 case 0x08: 11961 case 0x09: 11962 case 0x0a: 11963 case 0x0b: 11964 case 0x0c: 11965 case 0x0d: 11966 case 0x0e: 11967 goto op_semantics_88; 11968 break; 11969 case 0x0f: 11970 goto op_semantics_89; 11971 break; 11972 } 11973 break; 11974 case 0xfb: 11975 GETBYTE (); 11976 switch (op[2] & 0x0f) 11977 { 11978 case 0x00: 11979 case 0x01: 11980 case 0x02: 11981 case 0x03: 11982 case 0x04: 11983 case 0x05: 11984 case 0x06: 11985 case 0x07: 11986 case 0x08: 11987 case 0x09: 11988 case 0x0a: 11989 case 0x0b: 11990 case 0x0c: 11991 case 0x0d: 11992 case 0x0e: 11993 goto op_semantics_88; 11994 break; 11995 case 0x0f: 11996 goto op_semantics_89; 11997 break; 11998 } 11999 break; 12000 case 0xfc: 12001 GETBYTE (); 12002 switch (op[2] & 0x0f) 12003 { 12004 case 0x00: 12005 case 0x01: 12006 case 0x02: 12007 case 0x03: 12008 case 0x04: 12009 case 0x05: 12010 case 0x06: 12011 case 0x07: 12012 case 0x08: 12013 case 0x09: 12014 case 0x0a: 12015 case 0x0b: 12016 case 0x0c: 12017 case 0x0d: 12018 case 0x0e: 12019 goto op_semantics_88; 12020 break; 12021 case 0x0f: 12022 goto op_semantics_89; 12023 break; 12024 } 12025 break; 12026 case 0xfd: 12027 GETBYTE (); 12028 switch (op[2] & 0x0f) 12029 { 12030 case 0x00: 12031 case 0x01: 12032 case 0x02: 12033 case 0x03: 12034 case 0x04: 12035 case 0x05: 12036 case 0x06: 12037 case 0x07: 12038 case 0x08: 12039 case 0x09: 12040 case 0x0a: 12041 case 0x0b: 12042 case 0x0c: 12043 case 0x0d: 12044 case 0x0e: 12045 goto op_semantics_88; 12046 break; 12047 case 0x0f: 12048 goto op_semantics_89; 12049 break; 12050 } 12051 break; 12052 case 0xfe: 12053 GETBYTE (); 12054 switch (op[2] & 0x0f) 12055 { 12056 case 0x00: 12057 case 0x01: 12058 case 0x02: 12059 case 0x03: 12060 case 0x04: 12061 case 0x05: 12062 case 0x06: 12063 case 0x07: 12064 case 0x08: 12065 case 0x09: 12066 case 0x0a: 12067 case 0x0b: 12068 case 0x0c: 12069 case 0x0d: 12070 case 0x0e: 12071 goto op_semantics_88; 12072 break; 12073 case 0x0f: 12074 goto op_semantics_89; 12075 break; 12076 } 12077 break; 12078 case 0xff: 12079 GETBYTE (); 12080 switch (op[2] & 0x0f) 12081 { 12082 case 0x00: 12083 case 0x01: 12084 case 0x02: 12085 case 0x03: 12086 case 0x04: 12087 case 0x05: 12088 case 0x06: 12089 case 0x07: 12090 case 0x08: 12091 case 0x09: 12092 case 0x0a: 12093 case 0x0b: 12094 case 0x0c: 12095 case 0x0d: 12096 case 0x0e: 12097 goto op_semantics_88; 12098 break; 12099 case 0x0f: 12100 goto op_semantics_89; 12101 break; 12102 } 12103 break; 12104 default: UNSUPPORTED(); break; 12105 } 12106 break; 12107 case 0xfd: 12108 GETBYTE (); 12109 switch (op[1] & 0xff) 12110 { 12111 case 0x00: 12112 GETBYTE (); 12113 switch (op[2] & 0x00) 12114 { 12115 case 0x00: 12116 op_semantics_90: 12117 { 12118 /** 1111 1101 0000 a000 srca srcb mulhi %1, %2, %0 */ 12119 #line 873 "rx-decode.opc" 12120 int a AU = (op[1] >> 3) & 0x01; 12121 #line 873 "rx-decode.opc" 12122 int srca AU = (op[2] >> 4) & 0x0f; 12123 #line 873 "rx-decode.opc" 12124 int srcb AU = op[2] & 0x0f; 12125 if (trace) 12126 { 12127 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12128 "/** 1111 1101 0000 a000 srca srcb mulhi %1, %2, %0 */", 12129 op[0], op[1], op[2]); 12130 printf (" a = 0x%x,", a); 12131 printf (" srca = 0x%x,", srca); 12132 printf (" srcb = 0x%x\n", srcb); 12133 } 12134 SYNTAX("mulhi %1, %2, %0"); 12135 #line 873 "rx-decode.opc" 12136 ID(mulhi); DR(a+32); SR(srca); S2R(srcb); F_____; 12137 12138 } 12139 break; 12140 } 12141 break; 12142 case 0x01: 12143 GETBYTE (); 12144 switch (op[2] & 0x00) 12145 { 12146 case 0x00: 12147 op_semantics_91: 12148 { 12149 /** 1111 1101 0000 a001 srca srcb mullo %1, %2, %0 */ 12150 #line 876 "rx-decode.opc" 12151 int a AU = (op[1] >> 3) & 0x01; 12152 #line 876 "rx-decode.opc" 12153 int srca AU = (op[2] >> 4) & 0x0f; 12154 #line 876 "rx-decode.opc" 12155 int srcb AU = op[2] & 0x0f; 12156 if (trace) 12157 { 12158 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12159 "/** 1111 1101 0000 a001 srca srcb mullo %1, %2, %0 */", 12160 op[0], op[1], op[2]); 12161 printf (" a = 0x%x,", a); 12162 printf (" srca = 0x%x,", srca); 12163 printf (" srcb = 0x%x\n", srcb); 12164 } 12165 SYNTAX("mullo %1, %2, %0"); 12166 #line 876 "rx-decode.opc" 12167 ID(mullo); DR(a+32); SR(srca); S2R(srcb); F_____; 12168 12169 } 12170 break; 12171 } 12172 break; 12173 case 0x02: 12174 GETBYTE (); 12175 switch (op[2] & 0x00) 12176 { 12177 case 0x00: 12178 op_semantics_92: 12179 { 12180 /** 1111 1101 0000 a010 srca srcb mullh %1, %2, %0 */ 12181 #line 1104 "rx-decode.opc" 12182 int a AU = (op[1] >> 3) & 0x01; 12183 #line 1104 "rx-decode.opc" 12184 int srca AU = (op[2] >> 4) & 0x0f; 12185 #line 1104 "rx-decode.opc" 12186 int srcb AU = op[2] & 0x0f; 12187 if (trace) 12188 { 12189 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12190 "/** 1111 1101 0000 a010 srca srcb mullh %1, %2, %0 */", 12191 op[0], op[1], op[2]); 12192 printf (" a = 0x%x,", a); 12193 printf (" srca = 0x%x,", srca); 12194 printf (" srcb = 0x%x\n", srcb); 12195 } 12196 SYNTAX("mullh %1, %2, %0"); 12197 #line 1104 "rx-decode.opc" 12198 ID(mullh); DR(a+32); SR(srca); S2R(srcb); F_____; 12199 12200 } 12201 break; 12202 } 12203 break; 12204 case 0x03: 12205 GETBYTE (); 12206 switch (op[2] & 0x00) 12207 { 12208 case 0x00: 12209 op_semantics_93: 12210 { 12211 /** 1111 1101 0000 a011 srca srcb emula %1, %2, %0 */ 12212 #line 1089 "rx-decode.opc" 12213 int a AU = (op[1] >> 3) & 0x01; 12214 #line 1089 "rx-decode.opc" 12215 int srca AU = (op[2] >> 4) & 0x0f; 12216 #line 1089 "rx-decode.opc" 12217 int srcb AU = op[2] & 0x0f; 12218 if (trace) 12219 { 12220 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12221 "/** 1111 1101 0000 a011 srca srcb emula %1, %2, %0 */", 12222 op[0], op[1], op[2]); 12223 printf (" a = 0x%x,", a); 12224 printf (" srca = 0x%x,", srca); 12225 printf (" srcb = 0x%x\n", srcb); 12226 } 12227 SYNTAX("emula %1, %2, %0"); 12228 #line 1089 "rx-decode.opc" 12229 ID(emula); DR(a+32); SR(srca); S2R(srcb); F_____; 12230 12231 } 12232 break; 12233 } 12234 break; 12235 case 0x04: 12236 GETBYTE (); 12237 switch (op[2] & 0x00) 12238 { 12239 case 0x00: 12240 op_semantics_94: 12241 { 12242 /** 1111 1101 0000 a100 srca srcb machi %1, %2, %0 */ 12243 #line 879 "rx-decode.opc" 12244 int a AU = (op[1] >> 3) & 0x01; 12245 #line 879 "rx-decode.opc" 12246 int srca AU = (op[2] >> 4) & 0x0f; 12247 #line 879 "rx-decode.opc" 12248 int srcb AU = op[2] & 0x0f; 12249 if (trace) 12250 { 12251 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12252 "/** 1111 1101 0000 a100 srca srcb machi %1, %2, %0 */", 12253 op[0], op[1], op[2]); 12254 printf (" a = 0x%x,", a); 12255 printf (" srca = 0x%x,", srca); 12256 printf (" srcb = 0x%x\n", srcb); 12257 } 12258 SYNTAX("machi %1, %2, %0"); 12259 #line 879 "rx-decode.opc" 12260 ID(machi); DR(a+32); SR(srca); S2R(srcb); F_____; 12261 12262 } 12263 break; 12264 } 12265 break; 12266 case 0x05: 12267 GETBYTE (); 12268 switch (op[2] & 0x00) 12269 { 12270 case 0x00: 12271 op_semantics_95: 12272 { 12273 /** 1111 1101 0000 a101 srca srcb maclo %1, %2, %0 */ 12274 #line 882 "rx-decode.opc" 12275 int a AU = (op[1] >> 3) & 0x01; 12276 #line 882 "rx-decode.opc" 12277 int srca AU = (op[2] >> 4) & 0x0f; 12278 #line 882 "rx-decode.opc" 12279 int srcb AU = op[2] & 0x0f; 12280 if (trace) 12281 { 12282 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12283 "/** 1111 1101 0000 a101 srca srcb maclo %1, %2, %0 */", 12284 op[0], op[1], op[2]); 12285 printf (" a = 0x%x,", a); 12286 printf (" srca = 0x%x,", srca); 12287 printf (" srcb = 0x%x\n", srcb); 12288 } 12289 SYNTAX("maclo %1, %2, %0"); 12290 #line 882 "rx-decode.opc" 12291 ID(maclo); DR(a+32); SR(srca); S2R(srcb); F_____; 12292 12293 } 12294 break; 12295 } 12296 break; 12297 case 0x06: 12298 GETBYTE (); 12299 switch (op[2] & 0x00) 12300 { 12301 case 0x00: 12302 op_semantics_96: 12303 { 12304 /** 1111 1101 0000 a110 srca srcb maclh %1, %2, %0 */ 12305 #line 1092 "rx-decode.opc" 12306 int a AU = (op[1] >> 3) & 0x01; 12307 #line 1092 "rx-decode.opc" 12308 int srca AU = (op[2] >> 4) & 0x0f; 12309 #line 1092 "rx-decode.opc" 12310 int srcb AU = op[2] & 0x0f; 12311 if (trace) 12312 { 12313 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12314 "/** 1111 1101 0000 a110 srca srcb maclh %1, %2, %0 */", 12315 op[0], op[1], op[2]); 12316 printf (" a = 0x%x,", a); 12317 printf (" srca = 0x%x,", srca); 12318 printf (" srcb = 0x%x\n", srcb); 12319 } 12320 SYNTAX("maclh %1, %2, %0"); 12321 #line 1092 "rx-decode.opc" 12322 ID(maclh); DR(a+32); SR(srca); S2R(srcb); F_____; 12323 12324 } 12325 break; 12326 } 12327 break; 12328 case 0x07: 12329 GETBYTE (); 12330 switch (op[2] & 0x00) 12331 { 12332 case 0x00: 12333 op_semantics_97: 12334 { 12335 /** 1111 1101 0000 a111 srca srcb emaca %1, %2, %0 */ 12336 #line 1083 "rx-decode.opc" 12337 int a AU = (op[1] >> 3) & 0x01; 12338 #line 1083 "rx-decode.opc" 12339 int srca AU = (op[2] >> 4) & 0x0f; 12340 #line 1083 "rx-decode.opc" 12341 int srcb AU = op[2] & 0x0f; 12342 if (trace) 12343 { 12344 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12345 "/** 1111 1101 0000 a111 srca srcb emaca %1, %2, %0 */", 12346 op[0], op[1], op[2]); 12347 printf (" a = 0x%x,", a); 12348 printf (" srca = 0x%x,", srca); 12349 printf (" srcb = 0x%x\n", srcb); 12350 } 12351 SYNTAX("emaca %1, %2, %0"); 12352 #line 1083 "rx-decode.opc" 12353 ID(emaca); DR(a+32); SR(srca); S2R(srcb); F_____; 12354 12355 } 12356 break; 12357 } 12358 break; 12359 case 0x08: 12360 GETBYTE (); 12361 switch (op[2] & 0x00) 12362 { 12363 case 0x00: 12364 goto op_semantics_90; 12365 break; 12366 } 12367 break; 12368 case 0x09: 12369 GETBYTE (); 12370 switch (op[2] & 0x00) 12371 { 12372 case 0x00: 12373 goto op_semantics_91; 12374 break; 12375 } 12376 break; 12377 case 0x0a: 12378 GETBYTE (); 12379 switch (op[2] & 0x00) 12380 { 12381 case 0x00: 12382 goto op_semantics_92; 12383 break; 12384 } 12385 break; 12386 case 0x0b: 12387 GETBYTE (); 12388 switch (op[2] & 0x00) 12389 { 12390 case 0x00: 12391 goto op_semantics_93; 12392 break; 12393 } 12394 break; 12395 case 0x0c: 12396 GETBYTE (); 12397 switch (op[2] & 0x00) 12398 { 12399 case 0x00: 12400 goto op_semantics_94; 12401 break; 12402 } 12403 break; 12404 case 0x0d: 12405 GETBYTE (); 12406 switch (op[2] & 0x00) 12407 { 12408 case 0x00: 12409 goto op_semantics_95; 12410 break; 12411 } 12412 break; 12413 case 0x0e: 12414 GETBYTE (); 12415 switch (op[2] & 0x00) 12416 { 12417 case 0x00: 12418 goto op_semantics_96; 12419 break; 12420 } 12421 break; 12422 case 0x0f: 12423 GETBYTE (); 12424 switch (op[2] & 0x00) 12425 { 12426 case 0x00: 12427 goto op_semantics_97; 12428 break; 12429 } 12430 break; 12431 case 0x17: 12432 GETBYTE (); 12433 switch (op[2] & 0x70) 12434 { 12435 case 0x00: 12436 { 12437 /** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */ 12438 #line 885 "rx-decode.opc" 12439 int a AU = (op[2] >> 7) & 0x01; 12440 #line 885 "rx-decode.opc" 12441 int rsrc AU = op[2] & 0x0f; 12442 if (trace) 12443 { 12444 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12445 "/** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */", 12446 op[0], op[1], op[2]); 12447 printf (" a = 0x%x,", a); 12448 printf (" rsrc = 0x%x\n", rsrc); 12449 } 12450 SYNTAX("mvtachi %1, %0"); 12451 #line 885 "rx-decode.opc" 12452 ID(mvtachi); DR(a+32); SR(rsrc); F_____; 12453 12454 } 12455 break; 12456 case 0x10: 12457 { 12458 /** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */ 12459 #line 888 "rx-decode.opc" 12460 int a AU = (op[2] >> 7) & 0x01; 12461 #line 888 "rx-decode.opc" 12462 int rsrc AU = op[2] & 0x0f; 12463 if (trace) 12464 { 12465 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12466 "/** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */", 12467 op[0], op[1], op[2]); 12468 printf (" a = 0x%x,", a); 12469 printf (" rsrc = 0x%x\n", rsrc); 12470 } 12471 SYNTAX("mvtaclo %1, %0"); 12472 #line 888 "rx-decode.opc" 12473 ID(mvtaclo); DR(a+32); SR(rsrc); F_____; 12474 12475 } 12476 break; 12477 case 0x30: 12478 { 12479 /** 1111 1101 0001 0111 a011 rdst mvtacgu %0, %1 */ 12480 #line 1110 "rx-decode.opc" 12481 int a AU = (op[2] >> 7) & 0x01; 12482 #line 1110 "rx-decode.opc" 12483 int rdst AU = op[2] & 0x0f; 12484 if (trace) 12485 { 12486 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12487 "/** 1111 1101 0001 0111 a011 rdst mvtacgu %0, %1 */", 12488 op[0], op[1], op[2]); 12489 printf (" a = 0x%x,", a); 12490 printf (" rdst = 0x%x\n", rdst); 12491 } 12492 SYNTAX("mvtacgu %0, %1"); 12493 #line 1110 "rx-decode.opc" 12494 ID(mvtacgu); DR(a+32); SR(rdst); F_____; 12495 12496 } 12497 break; 12498 default: UNSUPPORTED(); break; 12499 } 12500 break; 12501 case 0x18: 12502 GETBYTE (); 12503 switch (op[2] & 0x6f) 12504 { 12505 case 0x00: 12506 { 12507 /** 1111 1101 0001 1000 a00i 0000 racw #%1, %0 */ 12508 #line 900 "rx-decode.opc" 12509 int a AU = (op[2] >> 7) & 0x01; 12510 #line 900 "rx-decode.opc" 12511 int i AU = (op[2] >> 4) & 0x01; 12512 if (trace) 12513 { 12514 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12515 "/** 1111 1101 0001 1000 a00i 0000 racw #%1, %0 */", 12516 op[0], op[1], op[2]); 12517 printf (" a = 0x%x,", a); 12518 printf (" i = 0x%x\n", i); 12519 } 12520 SYNTAX("racw #%1, %0"); 12521 #line 900 "rx-decode.opc" 12522 ID(racw); SC(i+1); DR(a+32); F_____; 12523 12524 /*----------------------------------------------------------------------*/ 12525 /* SAT */ 12526 12527 } 12528 break; 12529 case 0x40: 12530 { 12531 /** 1111 1101 0001 1000 a10i 0000 rdacw #%1, %0 */ 12532 #line 1119 "rx-decode.opc" 12533 int a AU = (op[2] >> 7) & 0x01; 12534 #line 1119 "rx-decode.opc" 12535 int i AU = (op[2] >> 4) & 0x01; 12536 if (trace) 12537 { 12538 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12539 "/** 1111 1101 0001 1000 a10i 0000 rdacw #%1, %0 */", 12540 op[0], op[1], op[2]); 12541 printf (" a = 0x%x,", a); 12542 printf (" i = 0x%x\n", i); 12543 } 12544 SYNTAX("rdacw #%1, %0"); 12545 #line 1119 "rx-decode.opc" 12546 ID(rdacw); SC(i+1); DR(a+32); F_____; 12547 12548 } 12549 break; 12550 default: UNSUPPORTED(); break; 12551 } 12552 break; 12553 case 0x19: 12554 GETBYTE (); 12555 switch (op[2] & 0x6f) 12556 { 12557 case 0x00: 12558 { 12559 /** 1111 1101 0001 1001 a00i 0000 racl #%1, %0 */ 12560 #line 1113 "rx-decode.opc" 12561 int a AU = (op[2] >> 7) & 0x01; 12562 #line 1113 "rx-decode.opc" 12563 int i AU = (op[2] >> 4) & 0x01; 12564 if (trace) 12565 { 12566 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12567 "/** 1111 1101 0001 1001 a00i 0000 racl #%1, %0 */", 12568 op[0], op[1], op[2]); 12569 printf (" a = 0x%x,", a); 12570 printf (" i = 0x%x\n", i); 12571 } 12572 SYNTAX("racl #%1, %0"); 12573 #line 1113 "rx-decode.opc" 12574 ID(racl); SC(i+1); DR(a+32); F_____; 12575 12576 } 12577 break; 12578 case 0x40: 12579 { 12580 /** 1111 1101 0001 1001 a10i 0000 rdacl #%1, %0 */ 12581 #line 1116 "rx-decode.opc" 12582 int a AU = (op[2] >> 7) & 0x01; 12583 #line 1116 "rx-decode.opc" 12584 int i AU = (op[2] >> 4) & 0x01; 12585 if (trace) 12586 { 12587 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12588 "/** 1111 1101 0001 1001 a10i 0000 rdacl #%1, %0 */", 12589 op[0], op[1], op[2]); 12590 printf (" a = 0x%x,", a); 12591 printf (" i = 0x%x\n", i); 12592 } 12593 SYNTAX("rdacl #%1, %0"); 12594 #line 1116 "rx-decode.opc" 12595 ID(rdacl); SC(i+1); DR(a+32); F_____; 12596 12597 } 12598 break; 12599 default: UNSUPPORTED(); break; 12600 } 12601 break; 12602 case 0x1e: 12603 GETBYTE (); 12604 switch (op[2] & 0x30) 12605 { 12606 case 0x00: 12607 op_semantics_98: 12608 { 12609 /** 1111 1101 0001 111i a m00 rdst mvfachi #%2, %1, %0 */ 12610 #line 891 "rx-decode.opc" 12611 int i AU = op[1] & 0x01; 12612 #line 891 "rx-decode.opc" 12613 int a AU = (op[2] >> 7) & 0x01; 12614 #line 891 "rx-decode.opc" 12615 int m AU = (op[2] >> 6) & 0x01; 12616 #line 891 "rx-decode.opc" 12617 int rdst AU = op[2] & 0x0f; 12618 if (trace) 12619 { 12620 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12621 "/** 1111 1101 0001 111i a m00 rdst mvfachi #%2, %1, %0 */", 12622 op[0], op[1], op[2]); 12623 printf (" i = 0x%x,", i); 12624 printf (" a = 0x%x,", a); 12625 printf (" m = 0x%x,", m); 12626 printf (" rdst = 0x%x\n", rdst); 12627 } 12628 SYNTAX("mvfachi #%2, %1, %0"); 12629 #line 891 "rx-decode.opc" 12630 ID(mvfachi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____; 12631 12632 } 12633 break; 12634 case 0x10: 12635 op_semantics_99: 12636 { 12637 /** 1111 1101 0001 111i a m01 rdst mvfaclo #%2, %1, %0 */ 12638 #line 897 "rx-decode.opc" 12639 int i AU = op[1] & 0x01; 12640 #line 897 "rx-decode.opc" 12641 int a AU = (op[2] >> 7) & 0x01; 12642 #line 897 "rx-decode.opc" 12643 int m AU = (op[2] >> 6) & 0x01; 12644 #line 897 "rx-decode.opc" 12645 int rdst AU = op[2] & 0x0f; 12646 if (trace) 12647 { 12648 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12649 "/** 1111 1101 0001 111i a m01 rdst mvfaclo #%2, %1, %0 */", 12650 op[0], op[1], op[2]); 12651 printf (" i = 0x%x,", i); 12652 printf (" a = 0x%x,", a); 12653 printf (" m = 0x%x,", m); 12654 printf (" rdst = 0x%x\n", rdst); 12655 } 12656 SYNTAX("mvfaclo #%2, %1, %0"); 12657 #line 897 "rx-decode.opc" 12658 ID(mvfaclo); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____; 12659 12660 } 12661 break; 12662 case 0x20: 12663 op_semantics_100: 12664 { 12665 /** 1111 1101 0001 111i a m10 rdst mvfacmi #%2, %1, %0 */ 12666 #line 894 "rx-decode.opc" 12667 int i AU = op[1] & 0x01; 12668 #line 894 "rx-decode.opc" 12669 int a AU = (op[2] >> 7) & 0x01; 12670 #line 894 "rx-decode.opc" 12671 int m AU = (op[2] >> 6) & 0x01; 12672 #line 894 "rx-decode.opc" 12673 int rdst AU = op[2] & 0x0f; 12674 if (trace) 12675 { 12676 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12677 "/** 1111 1101 0001 111i a m10 rdst mvfacmi #%2, %1, %0 */", 12678 op[0], op[1], op[2]); 12679 printf (" i = 0x%x,", i); 12680 printf (" a = 0x%x,", a); 12681 printf (" m = 0x%x,", m); 12682 printf (" rdst = 0x%x\n", rdst); 12683 } 12684 SYNTAX("mvfacmi #%2, %1, %0"); 12685 #line 894 "rx-decode.opc" 12686 ID(mvfacmi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____; 12687 12688 } 12689 break; 12690 case 0x30: 12691 op_semantics_101: 12692 { 12693 /** 1111 1101 0001 111i a m11 rdst mvfacgu #%2, %1, %0 */ 12694 #line 1107 "rx-decode.opc" 12695 int i AU = op[1] & 0x01; 12696 #line 1107 "rx-decode.opc" 12697 int a AU = (op[2] >> 7) & 0x01; 12698 #line 1107 "rx-decode.opc" 12699 int m AU = (op[2] >> 6) & 0x01; 12700 #line 1107 "rx-decode.opc" 12701 int rdst AU = op[2] & 0x0f; 12702 if (trace) 12703 { 12704 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12705 "/** 1111 1101 0001 111i a m11 rdst mvfacgu #%2, %1, %0 */", 12706 op[0], op[1], op[2]); 12707 printf (" i = 0x%x,", i); 12708 printf (" a = 0x%x,", a); 12709 printf (" m = 0x%x,", m); 12710 printf (" rdst = 0x%x\n", rdst); 12711 } 12712 SYNTAX("mvfacgu #%2, %1, %0"); 12713 #line 1107 "rx-decode.opc" 12714 ID(mvfacgu); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____; 12715 12716 } 12717 break; 12718 } 12719 break; 12720 case 0x1f: 12721 GETBYTE (); 12722 switch (op[2] & 0x30) 12723 { 12724 case 0x00: 12725 goto op_semantics_98; 12726 break; 12727 case 0x10: 12728 goto op_semantics_99; 12729 break; 12730 case 0x20: 12731 goto op_semantics_100; 12732 break; 12733 case 0x30: 12734 goto op_semantics_101; 12735 break; 12736 } 12737 break; 12738 case 0x20: 12739 GETBYTE (); 12740 switch (op[2] & 0x00) 12741 { 12742 case 0x00: 12743 op_semantics_102: 12744 { 12745 /** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */ 12746 #line 369 "rx-decode.opc" 12747 int p AU = (op[1] >> 2) & 0x01; 12748 #line 369 "rx-decode.opc" 12749 int sz AU = op[1] & 0x03; 12750 #line 369 "rx-decode.opc" 12751 int rdst AU = (op[2] >> 4) & 0x0f; 12752 #line 369 "rx-decode.opc" 12753 int rsrc AU = op[2] & 0x0f; 12754 if (trace) 12755 { 12756 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12757 "/** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */", 12758 op[0], op[1], op[2]); 12759 printf (" p = 0x%x,", p); 12760 printf (" sz = 0x%x,", sz); 12761 printf (" rdst = 0x%x,", rdst); 12762 printf (" rsrc = 0x%x\n", rsrc); 12763 } 12764 SYNTAX("mov%s %1, %0"); 12765 #line 369 "rx-decode.opc" 12766 ID(mov); sBWL (sz); SR(rsrc); F_____; 12767 OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0); 12768 12769 } 12770 break; 12771 } 12772 break; 12773 case 0x21: 12774 GETBYTE (); 12775 switch (op[2] & 0x00) 12776 { 12777 case 0x00: 12778 goto op_semantics_102; 12779 break; 12780 } 12781 break; 12782 case 0x22: 12783 GETBYTE (); 12784 switch (op[2] & 0x00) 12785 { 12786 case 0x00: 12787 goto op_semantics_102; 12788 break; 12789 } 12790 break; 12791 case 0x24: 12792 GETBYTE (); 12793 switch (op[2] & 0x00) 12794 { 12795 case 0x00: 12796 goto op_semantics_102; 12797 break; 12798 } 12799 break; 12800 case 0x25: 12801 GETBYTE (); 12802 switch (op[2] & 0x00) 12803 { 12804 case 0x00: 12805 goto op_semantics_102; 12806 break; 12807 } 12808 break; 12809 case 0x26: 12810 GETBYTE (); 12811 switch (op[2] & 0x00) 12812 { 12813 case 0x00: 12814 goto op_semantics_102; 12815 break; 12816 } 12817 break; 12818 case 0x27: 12819 GETBYTE (); 12820 switch (op[2] & 0x00) 12821 { 12822 case 0x00: 12823 { 12824 /** 1111 1101 0010 0111 rdst rsrc movco %1, [%0] */ 12825 #line 1071 "rx-decode.opc" 12826 int rdst AU = (op[2] >> 4) & 0x0f; 12827 #line 1071 "rx-decode.opc" 12828 int rsrc AU = op[2] & 0x0f; 12829 if (trace) 12830 { 12831 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12832 "/** 1111 1101 0010 0111 rdst rsrc movco %1, [%0] */", 12833 op[0], op[1], op[2]); 12834 printf (" rdst = 0x%x,", rdst); 12835 printf (" rsrc = 0x%x\n", rsrc); 12836 } 12837 SYNTAX("movco %1, [%0]"); 12838 #line 1071 "rx-decode.opc" 12839 ID(movco); SR(rsrc); DR(rdst); F_____; 12840 12841 } 12842 break; 12843 } 12844 break; 12845 case 0x28: 12846 GETBYTE (); 12847 switch (op[2] & 0x00) 12848 { 12849 case 0x00: 12850 op_semantics_103: 12851 { 12852 /** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */ 12853 #line 373 "rx-decode.opc" 12854 int p AU = (op[1] >> 2) & 0x01; 12855 #line 373 "rx-decode.opc" 12856 int sz AU = op[1] & 0x03; 12857 #line 373 "rx-decode.opc" 12858 int rsrc AU = (op[2] >> 4) & 0x0f; 12859 #line 373 "rx-decode.opc" 12860 int rdst AU = op[2] & 0x0f; 12861 if (trace) 12862 { 12863 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12864 "/** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */", 12865 op[0], op[1], op[2]); 12866 printf (" p = 0x%x,", p); 12867 printf (" sz = 0x%x,", sz); 12868 printf (" rsrc = 0x%x,", rsrc); 12869 printf (" rdst = 0x%x\n", rdst); 12870 } 12871 SYNTAX("mov%s %1, %0"); 12872 #line 373 "rx-decode.opc" 12873 ID(mov); sBWL (sz); DR(rdst); F_____; 12874 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0); 12875 12876 } 12877 break; 12878 } 12879 break; 12880 case 0x29: 12881 GETBYTE (); 12882 switch (op[2] & 0x00) 12883 { 12884 case 0x00: 12885 goto op_semantics_103; 12886 break; 12887 } 12888 break; 12889 case 0x2a: 12890 GETBYTE (); 12891 switch (op[2] & 0x00) 12892 { 12893 case 0x00: 12894 goto op_semantics_103; 12895 break; 12896 } 12897 break; 12898 case 0x2c: 12899 GETBYTE (); 12900 switch (op[2] & 0x00) 12901 { 12902 case 0x00: 12903 goto op_semantics_103; 12904 break; 12905 } 12906 break; 12907 case 0x2d: 12908 GETBYTE (); 12909 switch (op[2] & 0x00) 12910 { 12911 case 0x00: 12912 goto op_semantics_103; 12913 break; 12914 } 12915 break; 12916 case 0x2e: 12917 GETBYTE (); 12918 switch (op[2] & 0x00) 12919 { 12920 case 0x00: 12921 goto op_semantics_103; 12922 break; 12923 } 12924 break; 12925 case 0x2f: 12926 GETBYTE (); 12927 switch (op[2] & 0x00) 12928 { 12929 case 0x00: 12930 { 12931 /** 1111 1101 0010 1111 rsrc rdst movli [%1], %0 */ 12932 #line 1074 "rx-decode.opc" 12933 int rsrc AU = (op[2] >> 4) & 0x0f; 12934 #line 1074 "rx-decode.opc" 12935 int rdst AU = op[2] & 0x0f; 12936 if (trace) 12937 { 12938 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12939 "/** 1111 1101 0010 1111 rsrc rdst movli [%1], %0 */", 12940 op[0], op[1], op[2]); 12941 printf (" rsrc = 0x%x,", rsrc); 12942 printf (" rdst = 0x%x\n", rdst); 12943 } 12944 SYNTAX("movli [%1], %0"); 12945 #line 1074 "rx-decode.opc" 12946 ID(movli); SR(rsrc); DR(rdst); F_____; 12947 12948 } 12949 break; 12950 } 12951 break; 12952 case 0x38: 12953 GETBYTE (); 12954 switch (op[2] & 0x00) 12955 { 12956 case 0x00: 12957 op_semantics_104: 12958 { 12959 /** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */ 12960 #line 383 "rx-decode.opc" 12961 int p AU = (op[1] >> 2) & 0x01; 12962 #line 383 "rx-decode.opc" 12963 int sz AU = op[1] & 0x03; 12964 #line 383 "rx-decode.opc" 12965 int rsrc AU = (op[2] >> 4) & 0x0f; 12966 #line 383 "rx-decode.opc" 12967 int rdst AU = op[2] & 0x0f; 12968 if (trace) 12969 { 12970 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12971 "/** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */", 12972 op[0], op[1], op[2]); 12973 printf (" p = 0x%x,", p); 12974 printf (" sz = 0x%x,", sz); 12975 printf (" rsrc = 0x%x,", rsrc); 12976 printf (" rdst = 0x%x\n", rdst); 12977 } 12978 SYNTAX("movu%s %1, %0"); 12979 #line 383 "rx-decode.opc" 12980 ID(mov); uBW (sz); DR(rdst); F_____; 12981 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0); 12982 12983 /*----------------------------------------------------------------------*/ 12984 /* PUSH/POP */ 12985 12986 } 12987 break; 12988 } 12989 break; 12990 case 0x39: 12991 GETBYTE (); 12992 switch (op[2] & 0x00) 12993 { 12994 case 0x00: 12995 goto op_semantics_104; 12996 break; 12997 } 12998 break; 12999 case 0x3a: 13000 GETBYTE (); 13001 switch (op[2] & 0x00) 13002 { 13003 case 0x00: 13004 goto op_semantics_104; 13005 break; 13006 } 13007 break; 13008 case 0x3c: 13009 GETBYTE (); 13010 switch (op[2] & 0x00) 13011 { 13012 case 0x00: 13013 goto op_semantics_104; 13014 break; 13015 } 13016 break; 13017 case 0x3d: 13018 GETBYTE (); 13019 switch (op[2] & 0x00) 13020 { 13021 case 0x00: 13022 goto op_semantics_104; 13023 break; 13024 } 13025 break; 13026 case 0x3e: 13027 GETBYTE (); 13028 switch (op[2] & 0x00) 13029 { 13030 case 0x00: 13031 goto op_semantics_104; 13032 break; 13033 } 13034 break; 13035 case 0x44: 13036 GETBYTE (); 13037 switch (op[2] & 0x00) 13038 { 13039 case 0x00: 13040 op_semantics_105: 13041 { 13042 /** 1111 1101 0100 a100 srca srcb msbhi %1, %2, %0 */ 13043 #line 1095 "rx-decode.opc" 13044 int a AU = (op[1] >> 3) & 0x01; 13045 #line 1095 "rx-decode.opc" 13046 int srca AU = (op[2] >> 4) & 0x0f; 13047 #line 1095 "rx-decode.opc" 13048 int srcb AU = op[2] & 0x0f; 13049 if (trace) 13050 { 13051 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13052 "/** 1111 1101 0100 a100 srca srcb msbhi %1, %2, %0 */", 13053 op[0], op[1], op[2]); 13054 printf (" a = 0x%x,", a); 13055 printf (" srca = 0x%x,", srca); 13056 printf (" srcb = 0x%x\n", srcb); 13057 } 13058 SYNTAX("msbhi %1, %2, %0"); 13059 #line 1095 "rx-decode.opc" 13060 ID(msbhi); DR(a+32); SR(srca); S2R(srcb); F_____; 13061 13062 } 13063 break; 13064 } 13065 break; 13066 case 0x45: 13067 GETBYTE (); 13068 switch (op[2] & 0x00) 13069 { 13070 case 0x00: 13071 op_semantics_106: 13072 { 13073 /** 1111 1101 0100 a101 srca srcb msblo %1, %2, %0 */ 13074 #line 1101 "rx-decode.opc" 13075 int a AU = (op[1] >> 3) & 0x01; 13076 #line 1101 "rx-decode.opc" 13077 int srca AU = (op[2] >> 4) & 0x0f; 13078 #line 1101 "rx-decode.opc" 13079 int srcb AU = op[2] & 0x0f; 13080 if (trace) 13081 { 13082 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13083 "/** 1111 1101 0100 a101 srca srcb msblo %1, %2, %0 */", 13084 op[0], op[1], op[2]); 13085 printf (" a = 0x%x,", a); 13086 printf (" srca = 0x%x,", srca); 13087 printf (" srcb = 0x%x\n", srcb); 13088 } 13089 SYNTAX("msblo %1, %2, %0"); 13090 #line 1101 "rx-decode.opc" 13091 ID(msblo); DR(a+32); SR(srca); S2R(srcb); F_____; 13092 13093 } 13094 break; 13095 } 13096 break; 13097 case 0x46: 13098 GETBYTE (); 13099 switch (op[2] & 0x00) 13100 { 13101 case 0x00: 13102 op_semantics_107: 13103 { 13104 /** 1111 1101 0100 a110 srca srcb msblh %1, %2, %0 */ 13105 #line 1098 "rx-decode.opc" 13106 int a AU = (op[1] >> 3) & 0x01; 13107 #line 1098 "rx-decode.opc" 13108 int srca AU = (op[2] >> 4) & 0x0f; 13109 #line 1098 "rx-decode.opc" 13110 int srcb AU = op[2] & 0x0f; 13111 if (trace) 13112 { 13113 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13114 "/** 1111 1101 0100 a110 srca srcb msblh %1, %2, %0 */", 13115 op[0], op[1], op[2]); 13116 printf (" a = 0x%x,", a); 13117 printf (" srca = 0x%x,", srca); 13118 printf (" srcb = 0x%x\n", srcb); 13119 } 13120 SYNTAX("msblh %1, %2, %0"); 13121 #line 1098 "rx-decode.opc" 13122 ID(msblh); DR(a+32); SR(srca); S2R(srcb); F_____; 13123 13124 } 13125 break; 13126 } 13127 break; 13128 case 0x47: 13129 GETBYTE (); 13130 switch (op[2] & 0x00) 13131 { 13132 case 0x00: 13133 op_semantics_108: 13134 { 13135 /** 1111 1101 0100 a111 srca srcb emsba %1, %2, %0 */ 13136 #line 1086 "rx-decode.opc" 13137 int a AU = (op[1] >> 3) & 0x01; 13138 #line 1086 "rx-decode.opc" 13139 int srca AU = (op[2] >> 4) & 0x0f; 13140 #line 1086 "rx-decode.opc" 13141 int srcb AU = op[2] & 0x0f; 13142 if (trace) 13143 { 13144 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13145 "/** 1111 1101 0100 a111 srca srcb emsba %1, %2, %0 */", 13146 op[0], op[1], op[2]); 13147 printf (" a = 0x%x,", a); 13148 printf (" srca = 0x%x,", srca); 13149 printf (" srcb = 0x%x\n", srcb); 13150 } 13151 SYNTAX("emsba %1, %2, %0"); 13152 #line 1086 "rx-decode.opc" 13153 ID(emsba); DR(a+32); SR(srca); S2R(srcb); F_____; 13154 13155 } 13156 break; 13157 } 13158 break; 13159 case 0x4c: 13160 GETBYTE (); 13161 switch (op[2] & 0x00) 13162 { 13163 case 0x00: 13164 goto op_semantics_105; 13165 break; 13166 } 13167 break; 13168 case 0x4d: 13169 GETBYTE (); 13170 switch (op[2] & 0x00) 13171 { 13172 case 0x00: 13173 goto op_semantics_106; 13174 break; 13175 } 13176 break; 13177 case 0x4e: 13178 GETBYTE (); 13179 switch (op[2] & 0x00) 13180 { 13181 case 0x00: 13182 goto op_semantics_107; 13183 break; 13184 } 13185 break; 13186 case 0x4f: 13187 GETBYTE (); 13188 switch (op[2] & 0x00) 13189 { 13190 case 0x00: 13191 goto op_semantics_108; 13192 break; 13193 } 13194 break; 13195 case 0x60: 13196 GETBYTE (); 13197 switch (op[2] & 0x00) 13198 { 13199 case 0x00: 13200 { 13201 /** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */ 13202 #line 754 "rx-decode.opc" 13203 int rsrc AU = (op[2] >> 4) & 0x0f; 13204 #line 754 "rx-decode.opc" 13205 int rdst AU = op[2] & 0x0f; 13206 if (trace) 13207 { 13208 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13209 "/** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */", 13210 op[0], op[1], op[2]); 13211 printf (" rsrc = 0x%x,", rsrc); 13212 printf (" rdst = 0x%x\n", rdst); 13213 } 13214 SYNTAX("shlr %2, %0"); 13215 #line 754 "rx-decode.opc" 13216 ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F__SZC; 13217 13218 } 13219 break; 13220 } 13221 break; 13222 case 0x61: 13223 GETBYTE (); 13224 switch (op[2] & 0x00) 13225 { 13226 case 0x00: 13227 { 13228 /** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */ 13229 #line 744 "rx-decode.opc" 13230 int rsrc AU = (op[2] >> 4) & 0x0f; 13231 #line 744 "rx-decode.opc" 13232 int rdst AU = op[2] & 0x0f; 13233 if (trace) 13234 { 13235 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13236 "/** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */", 13237 op[0], op[1], op[2]); 13238 printf (" rsrc = 0x%x,", rsrc); 13239 printf (" rdst = 0x%x\n", rdst); 13240 } 13241 SYNTAX("shar %2, %0"); 13242 #line 744 "rx-decode.opc" 13243 ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F_0SZC; 13244 13245 } 13246 break; 13247 } 13248 break; 13249 case 0x62: 13250 GETBYTE (); 13251 switch (op[2] & 0x00) 13252 { 13253 case 0x00: 13254 { 13255 /** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */ 13256 #line 734 "rx-decode.opc" 13257 int rsrc AU = (op[2] >> 4) & 0x0f; 13258 #line 734 "rx-decode.opc" 13259 int rdst AU = op[2] & 0x0f; 13260 if (trace) 13261 { 13262 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13263 "/** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */", 13264 op[0], op[1], op[2]); 13265 printf (" rsrc = 0x%x,", rsrc); 13266 printf (" rdst = 0x%x\n", rdst); 13267 } 13268 SYNTAX("shll %2, %0"); 13269 #line 734 "rx-decode.opc" 13270 ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F_OSZC; 13271 13272 } 13273 break; 13274 } 13275 break; 13276 case 0x64: 13277 GETBYTE (); 13278 switch (op[2] & 0x00) 13279 { 13280 case 0x00: 13281 { 13282 /** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */ 13283 #line 778 "rx-decode.opc" 13284 int rsrc AU = (op[2] >> 4) & 0x0f; 13285 #line 778 "rx-decode.opc" 13286 int rdst AU = op[2] & 0x0f; 13287 if (trace) 13288 { 13289 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13290 "/** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */", 13291 op[0], op[1], op[2]); 13292 printf (" rsrc = 0x%x,", rsrc); 13293 printf (" rdst = 0x%x\n", rdst); 13294 } 13295 SYNTAX("rotr %1, %0"); 13296 #line 778 "rx-decode.opc" 13297 ID(rotr); SR(rsrc); DR(rdst); F__SZC; 13298 13299 } 13300 break; 13301 } 13302 break; 13303 case 0x65: 13304 GETBYTE (); 13305 switch (op[2] & 0x00) 13306 { 13307 case 0x00: 13308 { 13309 /** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */ 13310 #line 781 "rx-decode.opc" 13311 int rsrc AU = (op[2] >> 4) & 0x0f; 13312 #line 781 "rx-decode.opc" 13313 int rdst AU = op[2] & 0x0f; 13314 if (trace) 13315 { 13316 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13317 "/** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */", 13318 op[0], op[1], op[2]); 13319 printf (" rsrc = 0x%x,", rsrc); 13320 printf (" rdst = 0x%x\n", rdst); 13321 } 13322 SYNTAX("revw %1, %0"); 13323 #line 781 "rx-decode.opc" 13324 ID(revw); SR(rsrc); DR(rdst); 13325 13326 } 13327 break; 13328 } 13329 break; 13330 case 0x66: 13331 GETBYTE (); 13332 switch (op[2] & 0x00) 13333 { 13334 case 0x00: 13335 { 13336 /** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */ 13337 #line 772 "rx-decode.opc" 13338 int rsrc AU = (op[2] >> 4) & 0x0f; 13339 #line 772 "rx-decode.opc" 13340 int rdst AU = op[2] & 0x0f; 13341 if (trace) 13342 { 13343 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13344 "/** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */", 13345 op[0], op[1], op[2]); 13346 printf (" rsrc = 0x%x,", rsrc); 13347 printf (" rdst = 0x%x\n", rdst); 13348 } 13349 SYNTAX("rotl %1, %0"); 13350 #line 772 "rx-decode.opc" 13351 ID(rotl); SR(rsrc); DR(rdst); F__SZC; 13352 13353 } 13354 break; 13355 } 13356 break; 13357 case 0x67: 13358 GETBYTE (); 13359 switch (op[2] & 0x00) 13360 { 13361 case 0x00: 13362 { 13363 /** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */ 13364 #line 784 "rx-decode.opc" 13365 int rsrc AU = (op[2] >> 4) & 0x0f; 13366 #line 784 "rx-decode.opc" 13367 int rdst AU = op[2] & 0x0f; 13368 if (trace) 13369 { 13370 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13371 "/** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */", 13372 op[0], op[1], op[2]); 13373 printf (" rsrc = 0x%x,", rsrc); 13374 printf (" rdst = 0x%x\n", rdst); 13375 } 13376 SYNTAX("revl %1, %0"); 13377 #line 784 "rx-decode.opc" 13378 ID(revl); SR(rsrc); DR(rdst); 13379 13380 /*----------------------------------------------------------------------*/ 13381 /* BRANCH */ 13382 13383 } 13384 break; 13385 } 13386 break; 13387 case 0x68: 13388 GETBYTE (); 13389 switch (op[2] & 0x00) 13390 { 13391 case 0x00: 13392 op_semantics_109: 13393 { 13394 /** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */ 13395 #line 1035 "rx-decode.opc" 13396 int c AU = op[1] & 0x01; 13397 #line 1035 "rx-decode.opc" 13398 int rsrc AU = (op[2] >> 4) & 0x0f; 13399 #line 1035 "rx-decode.opc" 13400 int rdst AU = op[2] & 0x0f; 13401 if (trace) 13402 { 13403 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13404 "/** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */", 13405 op[0], op[1], op[2]); 13406 printf (" c = 0x%x,", c); 13407 printf (" rsrc = 0x%x,", rsrc); 13408 printf (" rdst = 0x%x\n", rdst); 13409 } 13410 SYNTAX("mvtc %1, %0"); 13411 #line 1035 "rx-decode.opc" 13412 ID(mov); SR(rsrc); DR(c*16+rdst + 16); 13413 13414 } 13415 break; 13416 } 13417 break; 13418 case 0x69: 13419 GETBYTE (); 13420 switch (op[2] & 0x00) 13421 { 13422 case 0x00: 13423 goto op_semantics_109; 13424 break; 13425 } 13426 break; 13427 case 0x6a: 13428 GETBYTE (); 13429 switch (op[2] & 0x00) 13430 { 13431 case 0x00: 13432 op_semantics_110: 13433 { 13434 /** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */ 13435 #line 1038 "rx-decode.opc" 13436 int s AU = op[1] & 0x01; 13437 #line 1038 "rx-decode.opc" 13438 int rsrc AU = (op[2] >> 4) & 0x0f; 13439 #line 1038 "rx-decode.opc" 13440 int rdst AU = op[2] & 0x0f; 13441 if (trace) 13442 { 13443 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13444 "/** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */", 13445 op[0], op[1], op[2]); 13446 printf (" s = 0x%x,", s); 13447 printf (" rsrc = 0x%x,", rsrc); 13448 printf (" rdst = 0x%x\n", rdst); 13449 } 13450 SYNTAX("mvfc %1, %0"); 13451 #line 1038 "rx-decode.opc" 13452 ID(mov); SR((s*16+rsrc) + 16); DR(rdst); 13453 13454 /*----------------------------------------------------------------------*/ 13455 /* INTERRUPTS */ 13456 13457 } 13458 break; 13459 } 13460 break; 13461 case 0x6b: 13462 GETBYTE (); 13463 switch (op[2] & 0x00) 13464 { 13465 case 0x00: 13466 goto op_semantics_110; 13467 break; 13468 } 13469 break; 13470 case 0x6c: 13471 GETBYTE (); 13472 switch (op[2] & 0x00) 13473 { 13474 case 0x00: 13475 op_semantics_111: 13476 { 13477 /** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */ 13478 #line 775 "rx-decode.opc" 13479 int i AU = op[1] & 0x01; 13480 #line 775 "rx-decode.opc" 13481 int mmmm AU = (op[2] >> 4) & 0x0f; 13482 #line 775 "rx-decode.opc" 13483 int rdst AU = op[2] & 0x0f; 13484 if (trace) 13485 { 13486 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13487 "/** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */", 13488 op[0], op[1], op[2]); 13489 printf (" i = 0x%x,", i); 13490 printf (" mmmm = 0x%x,", mmmm); 13491 printf (" rdst = 0x%x\n", rdst); 13492 } 13493 SYNTAX("rotr #%1, %0"); 13494 #line 775 "rx-decode.opc" 13495 ID(rotr); SC(i*16+mmmm); DR(rdst); F__SZC; 13496 13497 } 13498 break; 13499 } 13500 break; 13501 case 0x6d: 13502 GETBYTE (); 13503 switch (op[2] & 0x00) 13504 { 13505 case 0x00: 13506 goto op_semantics_111; 13507 break; 13508 } 13509 break; 13510 case 0x6e: 13511 GETBYTE (); 13512 switch (op[2] & 0x00) 13513 { 13514 case 0x00: 13515 op_semantics_112: 13516 { 13517 /** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */ 13518 #line 769 "rx-decode.opc" 13519 int i AU = op[1] & 0x01; 13520 #line 769 "rx-decode.opc" 13521 int mmmm AU = (op[2] >> 4) & 0x0f; 13522 #line 769 "rx-decode.opc" 13523 int rdst AU = op[2] & 0x0f; 13524 if (trace) 13525 { 13526 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13527 "/** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */", 13528 op[0], op[1], op[2]); 13529 printf (" i = 0x%x,", i); 13530 printf (" mmmm = 0x%x,", mmmm); 13531 printf (" rdst = 0x%x\n", rdst); 13532 } 13533 SYNTAX("rotl #%1, %0"); 13534 #line 769 "rx-decode.opc" 13535 ID(rotl); SC(i*16+mmmm); DR(rdst); F__SZC; 13536 13537 } 13538 break; 13539 } 13540 break; 13541 case 0x6f: 13542 GETBYTE (); 13543 switch (op[2] & 0x00) 13544 { 13545 case 0x00: 13546 goto op_semantics_112; 13547 break; 13548 } 13549 break; 13550 case 0x70: 13551 GETBYTE (); 13552 switch (op[2] & 0xf0) 13553 { 13554 case 0x20: 13555 op_semantics_113: 13556 { 13557 /** 1111 1101 0111 im00 0010rdst adc #%1, %0 */ 13558 #line 513 "rx-decode.opc" 13559 int im AU = (op[1] >> 2) & 0x03; 13560 #line 513 "rx-decode.opc" 13561 int rdst AU = op[2] & 0x0f; 13562 if (trace) 13563 { 13564 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13565 "/** 1111 1101 0111 im00 0010rdst adc #%1, %0 */", 13566 op[0], op[1], op[2]); 13567 printf (" im = 0x%x,", im); 13568 printf (" rdst = 0x%x\n", rdst); 13569 } 13570 SYNTAX("adc #%1, %0"); 13571 #line 513 "rx-decode.opc" 13572 ID(adc); SC(IMMex(im)); DR(rdst); F_OSZC; 13573 13574 } 13575 break; 13576 case 0x40: 13577 op_semantics_114: 13578 { 13579 /** 1111 1101 0111 im00 0100rdst max #%1, %0 */ 13580 #line 595 "rx-decode.opc" 13581 int im AU = (op[1] >> 2) & 0x03; 13582 #line 595 "rx-decode.opc" 13583 int rdst AU = op[2] & 0x0f; 13584 if (trace) 13585 { 13586 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13587 "/** 1111 1101 0111 im00 0100rdst max #%1, %0 */", 13588 op[0], op[1], op[2]); 13589 printf (" im = 0x%x,", im); 13590 printf (" rdst = 0x%x\n", rdst); 13591 } 13592 SYNTAX("max #%1, %0"); 13593 #line 595 "rx-decode.opc" 13594 int val = IMMex (im); 13595 if (im == 0 && (unsigned) val == 0x80000000 && rdst == 0) 13596 { 13597 ID (nop7); 13598 SYNTAX("nop\t; max\t#0x80000000, r0"); 13599 } 13600 else 13601 { 13602 ID(max); 13603 } 13604 DR(rdst); SC(val); 13605 13606 } 13607 break; 13608 case 0x50: 13609 op_semantics_115: 13610 { 13611 /** 1111 1101 0111 im00 0101rdst min #%1, %0 */ 13612 #line 625 "rx-decode.opc" 13613 int im AU = (op[1] >> 2) & 0x03; 13614 #line 625 "rx-decode.opc" 13615 int rdst AU = op[2] & 0x0f; 13616 if (trace) 13617 { 13618 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13619 "/** 1111 1101 0111 im00 0101rdst min #%1, %0 */", 13620 op[0], op[1], op[2]); 13621 printf (" im = 0x%x,", im); 13622 printf (" rdst = 0x%x\n", rdst); 13623 } 13624 SYNTAX("min #%1, %0"); 13625 #line 625 "rx-decode.opc" 13626 ID(min); DR(rdst); SC(IMMex(im)); 13627 13628 } 13629 break; 13630 case 0x60: 13631 op_semantics_116: 13632 { 13633 /** 1111 1101 0111 im00 0110rdst emul #%1, %0 */ 13634 #line 683 "rx-decode.opc" 13635 int im AU = (op[1] >> 2) & 0x03; 13636 #line 683 "rx-decode.opc" 13637 int rdst AU = op[2] & 0x0f; 13638 if (trace) 13639 { 13640 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13641 "/** 1111 1101 0111 im00 0110rdst emul #%1, %0 */", 13642 op[0], op[1], op[2]); 13643 printf (" im = 0x%x,", im); 13644 printf (" rdst = 0x%x\n", rdst); 13645 } 13646 SYNTAX("emul #%1, %0"); 13647 #line 683 "rx-decode.opc" 13648 ID(emul); DR(rdst); SC(IMMex(im)); 13649 13650 } 13651 break; 13652 case 0x70: 13653 op_semantics_117: 13654 { 13655 /** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */ 13656 #line 695 "rx-decode.opc" 13657 int im AU = (op[1] >> 2) & 0x03; 13658 #line 695 "rx-decode.opc" 13659 int rdst AU = op[2] & 0x0f; 13660 if (trace) 13661 { 13662 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13663 "/** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */", 13664 op[0], op[1], op[2]); 13665 printf (" im = 0x%x,", im); 13666 printf (" rdst = 0x%x\n", rdst); 13667 } 13668 SYNTAX("emulu #%1, %0"); 13669 #line 695 "rx-decode.opc" 13670 ID(emulu); DR(rdst); SC(IMMex(im)); 13671 13672 } 13673 break; 13674 case 0x80: 13675 op_semantics_118: 13676 { 13677 /** 1111 1101 0111 im00 1000rdst div #%1, %0 */ 13678 #line 707 "rx-decode.opc" 13679 int im AU = (op[1] >> 2) & 0x03; 13680 #line 707 "rx-decode.opc" 13681 int rdst AU = op[2] & 0x0f; 13682 if (trace) 13683 { 13684 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13685 "/** 1111 1101 0111 im00 1000rdst div #%1, %0 */", 13686 op[0], op[1], op[2]); 13687 printf (" im = 0x%x,", im); 13688 printf (" rdst = 0x%x\n", rdst); 13689 } 13690 SYNTAX("div #%1, %0"); 13691 #line 707 "rx-decode.opc" 13692 ID(div); DR(rdst); SC(IMMex(im)); F_O___; 13693 13694 } 13695 break; 13696 case 0x90: 13697 op_semantics_119: 13698 { 13699 /** 1111 1101 0111 im00 1001rdst divu #%1, %0 */ 13700 #line 719 "rx-decode.opc" 13701 int im AU = (op[1] >> 2) & 0x03; 13702 #line 719 "rx-decode.opc" 13703 int rdst AU = op[2] & 0x0f; 13704 if (trace) 13705 { 13706 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13707 "/** 1111 1101 0111 im00 1001rdst divu #%1, %0 */", 13708 op[0], op[1], op[2]); 13709 printf (" im = 0x%x,", im); 13710 printf (" rdst = 0x%x\n", rdst); 13711 } 13712 SYNTAX("divu #%1, %0"); 13713 #line 719 "rx-decode.opc" 13714 ID(divu); DR(rdst); SC(IMMex(im)); F_O___; 13715 13716 } 13717 break; 13718 case 0xc0: 13719 op_semantics_120: 13720 { 13721 /** 1111 1101 0111 im00 1100rdst tst #%1, %2 */ 13722 #line 492 "rx-decode.opc" 13723 int im AU = (op[1] >> 2) & 0x03; 13724 #line 492 "rx-decode.opc" 13725 int rdst AU = op[2] & 0x0f; 13726 if (trace) 13727 { 13728 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13729 "/** 1111 1101 0111 im00 1100rdst tst #%1, %2 */", 13730 op[0], op[1], op[2]); 13731 printf (" im = 0x%x,", im); 13732 printf (" rdst = 0x%x\n", rdst); 13733 } 13734 SYNTAX("tst #%1, %2"); 13735 #line 492 "rx-decode.opc" 13736 ID(and); SC(IMMex(im)); S2R(rdst); F__SZ_; 13737 13738 } 13739 break; 13740 case 0xd0: 13741 op_semantics_121: 13742 { 13743 /** 1111 1101 0111 im00 1101rdst xor #%1, %0 */ 13744 #line 471 "rx-decode.opc" 13745 int im AU = (op[1] >> 2) & 0x03; 13746 #line 471 "rx-decode.opc" 13747 int rdst AU = op[2] & 0x0f; 13748 if (trace) 13749 { 13750 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13751 "/** 1111 1101 0111 im00 1101rdst xor #%1, %0 */", 13752 op[0], op[1], op[2]); 13753 printf (" im = 0x%x,", im); 13754 printf (" rdst = 0x%x\n", rdst); 13755 } 13756 SYNTAX("xor #%1, %0"); 13757 #line 471 "rx-decode.opc" 13758 ID(xor); SC(IMMex(im)); DR(rdst); F__SZ_; 13759 13760 } 13761 break; 13762 case 0xe0: 13763 op_semantics_122: 13764 { 13765 /** 1111 1101 0111 im00 1110rdst stz #%1, %0 */ 13766 #line 417 "rx-decode.opc" 13767 int im AU = (op[1] >> 2) & 0x03; 13768 #line 417 "rx-decode.opc" 13769 int rdst AU = op[2] & 0x0f; 13770 if (trace) 13771 { 13772 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13773 "/** 1111 1101 0111 im00 1110rdst stz #%1, %0 */", 13774 op[0], op[1], op[2]); 13775 printf (" im = 0x%x,", im); 13776 printf (" rdst = 0x%x\n", rdst); 13777 } 13778 SYNTAX("stz #%1, %0"); 13779 #line 417 "rx-decode.opc" 13780 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z); 13781 13782 } 13783 break; 13784 case 0xf0: 13785 op_semantics_123: 13786 { 13787 /** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */ 13788 #line 420 "rx-decode.opc" 13789 int im AU = (op[1] >> 2) & 0x03; 13790 #line 420 "rx-decode.opc" 13791 int rdst AU = op[2] & 0x0f; 13792 if (trace) 13793 { 13794 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13795 "/** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */", 13796 op[0], op[1], op[2]); 13797 printf (" im = 0x%x,", im); 13798 printf (" rdst = 0x%x\n", rdst); 13799 } 13800 SYNTAX("stnz #%1, %0"); 13801 #line 420 "rx-decode.opc" 13802 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz); 13803 13804 /*----------------------------------------------------------------------*/ 13805 /* RTSD */ 13806 13807 } 13808 break; 13809 default: UNSUPPORTED(); break; 13810 } 13811 break; 13812 case 0x72: 13813 GETBYTE (); 13814 switch (op[2] & 0xf0) 13815 { 13816 case 0x00: 13817 { 13818 /** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */ 13819 #line 927 "rx-decode.opc" 13820 int rdst AU = op[2] & 0x0f; 13821 if (trace) 13822 { 13823 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13824 "/** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */", 13825 op[0], op[1], op[2]); 13826 printf (" rdst = 0x%x\n", rdst); 13827 } 13828 SYNTAX("fsub #%1, %0"); 13829 #line 927 "rx-decode.opc" 13830 ID(fsub); DR(rdst); SC(IMM(0)); F__SZ_; 13831 13832 } 13833 break; 13834 case 0x10: 13835 { 13836 /** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */ 13837 #line 921 "rx-decode.opc" 13838 int rdst AU = op[2] & 0x0f; 13839 if (trace) 13840 { 13841 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13842 "/** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */", 13843 op[0], op[1], op[2]); 13844 printf (" rdst = 0x%x\n", rdst); 13845 } 13846 SYNTAX("fcmp #%1, %0"); 13847 #line 921 "rx-decode.opc" 13848 ID(fcmp); DR(rdst); SC(IMM(0)); F_OSZ_; 13849 13850 } 13851 break; 13852 case 0x20: 13853 { 13854 /** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */ 13855 #line 915 "rx-decode.opc" 13856 int rdst AU = op[2] & 0x0f; 13857 if (trace) 13858 { 13859 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13860 "/** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */", 13861 op[0], op[1], op[2]); 13862 printf (" rdst = 0x%x\n", rdst); 13863 } 13864 SYNTAX("fadd #%1, %0"); 13865 #line 915 "rx-decode.opc" 13866 ID(fadd); DR(rdst); SC(IMM(0)); F__SZ_; 13867 13868 } 13869 break; 13870 case 0x30: 13871 { 13872 /** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */ 13873 #line 936 "rx-decode.opc" 13874 int rdst AU = op[2] & 0x0f; 13875 if (trace) 13876 { 13877 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13878 "/** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */", 13879 op[0], op[1], op[2]); 13880 printf (" rdst = 0x%x\n", rdst); 13881 } 13882 SYNTAX("fmul #%1, %0"); 13883 #line 936 "rx-decode.opc" 13884 ID(fmul); DR(rdst); SC(IMM(0)); F__SZ_; 13885 13886 } 13887 break; 13888 case 0x40: 13889 { 13890 /** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */ 13891 #line 942 "rx-decode.opc" 13892 int rdst AU = op[2] & 0x0f; 13893 if (trace) 13894 { 13895 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13896 "/** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */", 13897 op[0], op[1], op[2]); 13898 printf (" rdst = 0x%x\n", rdst); 13899 } 13900 SYNTAX("fdiv #%1, %0"); 13901 #line 942 "rx-decode.opc" 13902 ID(fdiv); DR(rdst); SC(IMM(0)); F__SZ_; 13903 13904 } 13905 break; 13906 default: UNSUPPORTED(); break; 13907 } 13908 break; 13909 case 0x73: 13910 GETBYTE (); 13911 switch (op[2] & 0xe0) 13912 { 13913 case 0x00: 13914 op_semantics_124: 13915 { 13916 /** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */ 13917 #line 1032 "rx-decode.opc" 13918 int im AU = (op[1] >> 2) & 0x03; 13919 #line 1032 "rx-decode.opc" 13920 int crdst AU = op[2] & 0x1f; 13921 if (trace) 13922 { 13923 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13924 "/** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */", 13925 op[0], op[1], op[2]); 13926 printf (" im = 0x%x,", im); 13927 printf (" crdst = 0x%x\n", crdst); 13928 } 13929 SYNTAX("mvtc #%1, %0"); 13930 #line 1032 "rx-decode.opc" 13931 ID(mov); SC(IMMex(im)); DR(crdst + 16); 13932 13933 } 13934 break; 13935 default: UNSUPPORTED(); break; 13936 } 13937 break; 13938 case 0x74: 13939 GETBYTE (); 13940 switch (op[2] & 0xf0) 13941 { 13942 case 0x20: 13943 goto op_semantics_113; 13944 break; 13945 case 0x40: 13946 goto op_semantics_114; 13947 break; 13948 case 0x50: 13949 goto op_semantics_115; 13950 break; 13951 case 0x60: 13952 goto op_semantics_116; 13953 break; 13954 case 0x70: 13955 goto op_semantics_117; 13956 break; 13957 case 0x80: 13958 goto op_semantics_118; 13959 break; 13960 case 0x90: 13961 goto op_semantics_119; 13962 break; 13963 case 0xc0: 13964 goto op_semantics_120; 13965 break; 13966 case 0xd0: 13967 goto op_semantics_121; 13968 break; 13969 case 0xe0: 13970 goto op_semantics_122; 13971 break; 13972 case 0xf0: 13973 goto op_semantics_123; 13974 break; 13975 default: UNSUPPORTED(); break; 13976 } 13977 break; 13978 case 0x75: 13979 GETBYTE (); 13980 switch (op[2] & 0xff) 13981 { 13982 case 0x80: 13983 GETBYTE (); 13984 switch (op[3] & 0x0f) 13985 { 13986 case 0x00: 13987 op_semantics_125: 13988 { 13989 /** 1111 1101 0111 0101 1000 rdst rsrc 0000 dmov.l %1, %0 */ 13990 #line 1176 "rx-decode.opc" 13991 int rdst AU = op[2] & 0x0f; 13992 #line 1176 "rx-decode.opc" 13993 int rsrc AU = (op[3] >> 4) & 0x0f; 13994 if (trace) 13995 { 13996 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 13997 "/** 1111 1101 0111 0101 1000 rdst rsrc 0000 dmov.l %1, %0 */", 13998 op[0], op[1], op[2], op[3]); 13999 printf (" rdst = 0x%x,", rdst); 14000 printf (" rsrc = 0x%x\n", rsrc); 14001 } 14002 SYNTAX("dmov.l %1, %0"); 14003 #line 1176 "rx-decode.opc" 14004 ID(dmov); DR(rdst); SDRL(rsrc); F_____; 14005 14006 } 14007 break; 14008 case 0x02: 14009 op_semantics_126: 14010 { 14011 /** 1111 1101 0111 0101 1000 rdst rsrc 0010 dmov.l %1, %0 */ 14012 #line 1173 "rx-decode.opc" 14013 int rdst AU = op[2] & 0x0f; 14014 #line 1173 "rx-decode.opc" 14015 int rsrc AU = (op[3] >> 4) & 0x0f; 14016 if (trace) 14017 { 14018 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 14019 "/** 1111 1101 0111 0101 1000 rdst rsrc 0010 dmov.l %1, %0 */", 14020 op[0], op[1], op[2], op[3]); 14021 printf (" rdst = 0x%x,", rdst); 14022 printf (" rsrc = 0x%x\n", rsrc); 14023 } 14024 SYNTAX("dmov.l %1, %0"); 14025 #line 1173 "rx-decode.opc" 14026 ID(dmov); DR(rdst); SDRH(rsrc); F_____; 14027 14028 } 14029 break; 14030 case 0x04: 14031 op_semantics_127: 14032 { 14033 /** 1111 1101 0111 0101 1000 rdst rsrc 0100 mvfdc %1, %0 */ 14034 #line 1226 "rx-decode.opc" 14035 int rdst AU = op[2] & 0x0f; 14036 #line 1226 "rx-decode.opc" 14037 int rsrc AU = (op[3] >> 4) & 0x0f; 14038 if (trace) 14039 { 14040 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 14041 "/** 1111 1101 0111 0101 1000 rdst rsrc 0100 mvfdc %1, %0 */", 14042 op[0], op[1], op[2], op[3]); 14043 printf (" rdst = 0x%x,", rdst); 14044 printf (" rsrc = 0x%x\n", rsrc); 14045 } 14046 SYNTAX("mvfdc %1, %0"); 14047 #line 1226 "rx-decode.opc" 14048 ID(mvfdc); DR(rdst); SCR(rsrc); F_____; 14049 14050 } 14051 break; 14052 default: UNSUPPORTED(); break; 14053 } 14054 break; 14055 case 0x81: 14056 GETBYTE (); 14057 switch (op[3] & 0x0f) 14058 { 14059 case 0x00: 14060 goto op_semantics_125; 14061 break; 14062 case 0x02: 14063 goto op_semantics_126; 14064 break; 14065 case 0x04: 14066 goto op_semantics_127; 14067 break; 14068 default: UNSUPPORTED(); break; 14069 } 14070 break; 14071 case 0x82: 14072 GETBYTE (); 14073 switch (op[3] & 0x0f) 14074 { 14075 case 0x00: 14076 goto op_semantics_125; 14077 break; 14078 case 0x02: 14079 goto op_semantics_126; 14080 break; 14081 case 0x04: 14082 goto op_semantics_127; 14083 break; 14084 default: UNSUPPORTED(); break; 14085 } 14086 break; 14087 case 0x83: 14088 GETBYTE (); 14089 switch (op[3] & 0x0f) 14090 { 14091 case 0x00: 14092 goto op_semantics_125; 14093 break; 14094 case 0x02: 14095 goto op_semantics_126; 14096 break; 14097 case 0x04: 14098 goto op_semantics_127; 14099 break; 14100 default: UNSUPPORTED(); break; 14101 } 14102 break; 14103 case 0x84: 14104 GETBYTE (); 14105 switch (op[3] & 0x0f) 14106 { 14107 case 0x00: 14108 goto op_semantics_125; 14109 break; 14110 case 0x02: 14111 goto op_semantics_126; 14112 break; 14113 case 0x04: 14114 goto op_semantics_127; 14115 break; 14116 default: UNSUPPORTED(); break; 14117 } 14118 break; 14119 case 0x85: 14120 GETBYTE (); 14121 switch (op[3] & 0x0f) 14122 { 14123 case 0x00: 14124 goto op_semantics_125; 14125 break; 14126 case 0x02: 14127 goto op_semantics_126; 14128 break; 14129 case 0x04: 14130 goto op_semantics_127; 14131 break; 14132 default: UNSUPPORTED(); break; 14133 } 14134 break; 14135 case 0x86: 14136 GETBYTE (); 14137 switch (op[3] & 0x0f) 14138 { 14139 case 0x00: 14140 goto op_semantics_125; 14141 break; 14142 case 0x02: 14143 goto op_semantics_126; 14144 break; 14145 case 0x04: 14146 goto op_semantics_127; 14147 break; 14148 default: UNSUPPORTED(); break; 14149 } 14150 break; 14151 case 0x87: 14152 GETBYTE (); 14153 switch (op[3] & 0x0f) 14154 { 14155 case 0x00: 14156 goto op_semantics_125; 14157 break; 14158 case 0x02: 14159 goto op_semantics_126; 14160 break; 14161 case 0x04: 14162 goto op_semantics_127; 14163 break; 14164 default: UNSUPPORTED(); break; 14165 } 14166 break; 14167 case 0x88: 14168 GETBYTE (); 14169 switch (op[3] & 0x0f) 14170 { 14171 case 0x00: 14172 goto op_semantics_125; 14173 break; 14174 case 0x02: 14175 goto op_semantics_126; 14176 break; 14177 case 0x04: 14178 goto op_semantics_127; 14179 break; 14180 default: UNSUPPORTED(); break; 14181 } 14182 break; 14183 case 0x89: 14184 GETBYTE (); 14185 switch (op[3] & 0x0f) 14186 { 14187 case 0x00: 14188 goto op_semantics_125; 14189 break; 14190 case 0x02: 14191 goto op_semantics_126; 14192 break; 14193 case 0x04: 14194 goto op_semantics_127; 14195 break; 14196 default: UNSUPPORTED(); break; 14197 } 14198 break; 14199 case 0x8a: 14200 GETBYTE (); 14201 switch (op[3] & 0x0f) 14202 { 14203 case 0x00: 14204 goto op_semantics_125; 14205 break; 14206 case 0x02: 14207 goto op_semantics_126; 14208 break; 14209 case 0x04: 14210 goto op_semantics_127; 14211 break; 14212 default: UNSUPPORTED(); break; 14213 } 14214 break; 14215 case 0x8b: 14216 GETBYTE (); 14217 switch (op[3] & 0x0f) 14218 { 14219 case 0x00: 14220 goto op_semantics_125; 14221 break; 14222 case 0x02: 14223 goto op_semantics_126; 14224 break; 14225 case 0x04: 14226 goto op_semantics_127; 14227 break; 14228 default: UNSUPPORTED(); break; 14229 } 14230 break; 14231 case 0x8c: 14232 GETBYTE (); 14233 switch (op[3] & 0x0f) 14234 { 14235 case 0x00: 14236 goto op_semantics_125; 14237 break; 14238 case 0x02: 14239 goto op_semantics_126; 14240 break; 14241 case 0x04: 14242 goto op_semantics_127; 14243 break; 14244 default: UNSUPPORTED(); break; 14245 } 14246 break; 14247 case 0x8d: 14248 GETBYTE (); 14249 switch (op[3] & 0x0f) 14250 { 14251 case 0x00: 14252 goto op_semantics_125; 14253 break; 14254 case 0x02: 14255 goto op_semantics_126; 14256 break; 14257 case 0x04: 14258 goto op_semantics_127; 14259 break; 14260 default: UNSUPPORTED(); break; 14261 } 14262 break; 14263 case 0x8e: 14264 GETBYTE (); 14265 switch (op[3] & 0x0f) 14266 { 14267 case 0x00: 14268 goto op_semantics_125; 14269 break; 14270 case 0x02: 14271 goto op_semantics_126; 14272 break; 14273 case 0x04: 14274 goto op_semantics_127; 14275 break; 14276 default: UNSUPPORTED(); break; 14277 } 14278 break; 14279 case 0x8f: 14280 GETBYTE (); 14281 switch (op[3] & 0x0f) 14282 { 14283 case 0x00: 14284 goto op_semantics_125; 14285 break; 14286 case 0x02: 14287 goto op_semantics_126; 14288 break; 14289 case 0x04: 14290 goto op_semantics_127; 14291 break; 14292 default: UNSUPPORTED(); break; 14293 } 14294 break; 14295 default: UNSUPPORTED(); break; 14296 } 14297 break; 14298 case 0x76: 14299 GETBYTE (); 14300 switch (op[2] & 0xff) 14301 { 14302 case 0xc0: 14303 GETBYTE (); 14304 switch (op[3] & 0xff) 14305 { 14306 case 0x00: 14307 op_semantics_128: 14308 { 14309 /** 1111 1101 0111 0110 1100 rsrc 0000 0000 save %1 */ 14310 #line 1161 "rx-decode.opc" 14311 int rsrc AU = op[2] & 0x0f; 14312 if (trace) 14313 { 14314 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 14315 "/** 1111 1101 0111 0110 1100 rsrc 0000 0000 save %1 */", 14316 op[0], op[1], op[2], op[3]); 14317 printf (" rsrc = 0x%x\n", rsrc); 14318 } 14319 SYNTAX("save %1"); 14320 #line 1161 "rx-decode.opc" 14321 ID(save); SR(rsrc); F_____; 14322 14323 } 14324 break; 14325 default: UNSUPPORTED(); break; 14326 } 14327 break; 14328 case 0xc1: 14329 GETBYTE (); 14330 switch (op[3] & 0xff) 14331 { 14332 case 0x00: 14333 goto op_semantics_128; 14334 break; 14335 default: UNSUPPORTED(); break; 14336 } 14337 break; 14338 case 0xc2: 14339 GETBYTE (); 14340 switch (op[3] & 0xff) 14341 { 14342 case 0x00: 14343 goto op_semantics_128; 14344 break; 14345 default: UNSUPPORTED(); break; 14346 } 14347 break; 14348 case 0xc3: 14349 GETBYTE (); 14350 switch (op[3] & 0xff) 14351 { 14352 case 0x00: 14353 goto op_semantics_128; 14354 break; 14355 default: UNSUPPORTED(); break; 14356 } 14357 break; 14358 case 0xc4: 14359 GETBYTE (); 14360 switch (op[3] & 0xff) 14361 { 14362 case 0x00: 14363 goto op_semantics_128; 14364 break; 14365 default: UNSUPPORTED(); break; 14366 } 14367 break; 14368 case 0xc5: 14369 GETBYTE (); 14370 switch (op[3] & 0xff) 14371 { 14372 case 0x00: 14373 goto op_semantics_128; 14374 break; 14375 default: UNSUPPORTED(); break; 14376 } 14377 break; 14378 case 0xc6: 14379 GETBYTE (); 14380 switch (op[3] & 0xff) 14381 { 14382 case 0x00: 14383 goto op_semantics_128; 14384 break; 14385 default: UNSUPPORTED(); break; 14386 } 14387 break; 14388 case 0xc7: 14389 GETBYTE (); 14390 switch (op[3] & 0xff) 14391 { 14392 case 0x00: 14393 goto op_semantics_128; 14394 break; 14395 default: UNSUPPORTED(); break; 14396 } 14397 break; 14398 case 0xc8: 14399 GETBYTE (); 14400 switch (op[3] & 0xff) 14401 { 14402 case 0x00: 14403 goto op_semantics_128; 14404 break; 14405 default: UNSUPPORTED(); break; 14406 } 14407 break; 14408 case 0xc9: 14409 GETBYTE (); 14410 switch (op[3] & 0xff) 14411 { 14412 case 0x00: 14413 goto op_semantics_128; 14414 break; 14415 default: UNSUPPORTED(); break; 14416 } 14417 break; 14418 case 0xca: 14419 GETBYTE (); 14420 switch (op[3] & 0xff) 14421 { 14422 case 0x00: 14423 goto op_semantics_128; 14424 break; 14425 default: UNSUPPORTED(); break; 14426 } 14427 break; 14428 case 0xcb: 14429 GETBYTE (); 14430 switch (op[3] & 0xff) 14431 { 14432 case 0x00: 14433 goto op_semantics_128; 14434 break; 14435 default: UNSUPPORTED(); break; 14436 } 14437 break; 14438 case 0xcc: 14439 GETBYTE (); 14440 switch (op[3] & 0xff) 14441 { 14442 case 0x00: 14443 goto op_semantics_128; 14444 break; 14445 default: UNSUPPORTED(); break; 14446 } 14447 break; 14448 case 0xcd: 14449 GETBYTE (); 14450 switch (op[3] & 0xff) 14451 { 14452 case 0x00: 14453 goto op_semantics_128; 14454 break; 14455 default: UNSUPPORTED(); break; 14456 } 14457 break; 14458 case 0xce: 14459 GETBYTE (); 14460 switch (op[3] & 0xff) 14461 { 14462 case 0x00: 14463 goto op_semantics_128; 14464 break; 14465 default: UNSUPPORTED(); break; 14466 } 14467 break; 14468 case 0xcf: 14469 GETBYTE (); 14470 switch (op[3] & 0xff) 14471 { 14472 case 0x00: 14473 goto op_semantics_128; 14474 break; 14475 default: UNSUPPORTED(); break; 14476 } 14477 break; 14478 case 0xd0: 14479 GETBYTE (); 14480 switch (op[3] & 0xff) 14481 { 14482 case 0x00: 14483 op_semantics_129: 14484 { 14485 /** 1111 1101 0111 0110 1101 rsrc 0000 0000 rstr %1 */ 14486 #line 1155 "rx-decode.opc" 14487 int rsrc AU = op[2] & 0x0f; 14488 if (trace) 14489 { 14490 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 14491 "/** 1111 1101 0111 0110 1101 rsrc 0000 0000 rstr %1 */", 14492 op[0], op[1], op[2], op[3]); 14493 printf (" rsrc = 0x%x\n", rsrc); 14494 } 14495 SYNTAX("rstr %1"); 14496 #line 1155 "rx-decode.opc" 14497 ID(rstr); SR(rsrc); F_____; 14498 14499 } 14500 break; 14501 default: UNSUPPORTED(); break; 14502 } 14503 break; 14504 case 0xd1: 14505 GETBYTE (); 14506 switch (op[3] & 0xff) 14507 { 14508 case 0x00: 14509 goto op_semantics_129; 14510 break; 14511 default: UNSUPPORTED(); break; 14512 } 14513 break; 14514 case 0xd2: 14515 GETBYTE (); 14516 switch (op[3] & 0xff) 14517 { 14518 case 0x00: 14519 goto op_semantics_129; 14520 break; 14521 default: UNSUPPORTED(); break; 14522 } 14523 break; 14524 case 0xd3: 14525 GETBYTE (); 14526 switch (op[3] & 0xff) 14527 { 14528 case 0x00: 14529 goto op_semantics_129; 14530 break; 14531 default: UNSUPPORTED(); break; 14532 } 14533 break; 14534 case 0xd4: 14535 GETBYTE (); 14536 switch (op[3] & 0xff) 14537 { 14538 case 0x00: 14539 goto op_semantics_129; 14540 break; 14541 default: UNSUPPORTED(); break; 14542 } 14543 break; 14544 case 0xd5: 14545 GETBYTE (); 14546 switch (op[3] & 0xff) 14547 { 14548 case 0x00: 14549 goto op_semantics_129; 14550 break; 14551 default: UNSUPPORTED(); break; 14552 } 14553 break; 14554 case 0xd6: 14555 GETBYTE (); 14556 switch (op[3] & 0xff) 14557 { 14558 case 0x00: 14559 goto op_semantics_129; 14560 break; 14561 default: UNSUPPORTED(); break; 14562 } 14563 break; 14564 case 0xd7: 14565 GETBYTE (); 14566 switch (op[3] & 0xff) 14567 { 14568 case 0x00: 14569 goto op_semantics_129; 14570 break; 14571 default: UNSUPPORTED(); break; 14572 } 14573 break; 14574 case 0xd8: 14575 GETBYTE (); 14576 switch (op[3] & 0xff) 14577 { 14578 case 0x00: 14579 goto op_semantics_129; 14580 break; 14581 default: UNSUPPORTED(); break; 14582 } 14583 break; 14584 case 0xd9: 14585 GETBYTE (); 14586 switch (op[3] & 0xff) 14587 { 14588 case 0x00: 14589 goto op_semantics_129; 14590 break; 14591 default: UNSUPPORTED(); break; 14592 } 14593 break; 14594 case 0xda: 14595 GETBYTE (); 14596 switch (op[3] & 0xff) 14597 { 14598 case 0x00: 14599 goto op_semantics_129; 14600 break; 14601 default: UNSUPPORTED(); break; 14602 } 14603 break; 14604 case 0xdb: 14605 GETBYTE (); 14606 switch (op[3] & 0xff) 14607 { 14608 case 0x00: 14609 goto op_semantics_129; 14610 break; 14611 default: UNSUPPORTED(); break; 14612 } 14613 break; 14614 case 0xdc: 14615 GETBYTE (); 14616 switch (op[3] & 0xff) 14617 { 14618 case 0x00: 14619 goto op_semantics_129; 14620 break; 14621 default: UNSUPPORTED(); break; 14622 } 14623 break; 14624 case 0xdd: 14625 GETBYTE (); 14626 switch (op[3] & 0xff) 14627 { 14628 case 0x00: 14629 goto op_semantics_129; 14630 break; 14631 default: UNSUPPORTED(); break; 14632 } 14633 break; 14634 case 0xde: 14635 GETBYTE (); 14636 switch (op[3] & 0xff) 14637 { 14638 case 0x00: 14639 goto op_semantics_129; 14640 break; 14641 default: UNSUPPORTED(); break; 14642 } 14643 break; 14644 case 0xdf: 14645 GETBYTE (); 14646 switch (op[3] & 0xff) 14647 { 14648 case 0x00: 14649 goto op_semantics_129; 14650 break; 14651 default: UNSUPPORTED(); break; 14652 } 14653 break; 14654 case 0xe0: 14655 { 14656 /** 1111 1101 0111 0110 1110 0000 save #%1 */ 14657 if (trace) 14658 { 14659 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 14660 "/** 1111 1101 0111 0110 1110 0000 save #%1 */", 14661 op[0], op[1], op[2]); 14662 } 14663 SYNTAX("save #%1"); 14664 #line 1164 "rx-decode.opc" 14665 ID(save); SC(IMM(1)); F_____; 14666 14667 } 14668 break; 14669 case 0xf0: 14670 { 14671 /** 1111 1101 0111 0110 1111 0000 rstr #%1 */ 14672 if (trace) 14673 { 14674 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 14675 "/** 1111 1101 0111 0110 1111 0000 rstr #%1 */", 14676 op[0], op[1], op[2]); 14677 } 14678 SYNTAX("rstr #%1"); 14679 #line 1158 "rx-decode.opc" 14680 ID(rstr); SC(IMM(1)); F_____; 14681 14682 } 14683 break; 14684 default: UNSUPPORTED(); break; 14685 } 14686 break; 14687 case 0x77: 14688 GETBYTE (); 14689 switch (op[2] & 0xff) 14690 { 14691 case 0x00: 14692 case 0x01: 14693 case 0x02: 14694 case 0x03: 14695 case 0x04: 14696 case 0x05: 14697 case 0x06: 14698 case 0x07: 14699 case 0x08: 14700 case 0x09: 14701 case 0x0a: 14702 case 0x0b: 14703 case 0x0c: 14704 case 0x0d: 14705 case 0x0e: 14706 case 0x0f: 14707 case 0x10: 14708 case 0x11: 14709 case 0x12: 14710 case 0x13: 14711 case 0x14: 14712 case 0x15: 14713 case 0x16: 14714 case 0x17: 14715 case 0x18: 14716 case 0x19: 14717 case 0x1a: 14718 case 0x1b: 14719 case 0x1c: 14720 case 0x1d: 14721 case 0x1e: 14722 case 0x1f: 14723 goto op_semantics_124; 14724 break; 14725 case 0x80: 14726 GETBYTE (); 14727 switch (op[3] & 0x0f) 14728 { 14729 case 0x00: 14730 op_semantics_130: 14731 { 14732 /** 1111 1101 0111 0111 1000 rsrc rdst 0000 dmov.l %1, %0 */ 14733 #line 1170 "rx-decode.opc" 14734 int rsrc AU = op[2] & 0x0f; 14735 #line 1170 "rx-decode.opc" 14736 int rdst AU = (op[3] >> 4) & 0x0f; 14737 if (trace) 14738 { 14739 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 14740 "/** 1111 1101 0111 0111 1000 rsrc rdst 0000 dmov.l %1, %0 */", 14741 op[0], op[1], op[2], op[3]); 14742 printf (" rsrc = 0x%x,", rsrc); 14743 printf (" rdst = 0x%x\n", rdst); 14744 } 14745 SYNTAX("dmov.l %1, %0"); 14746 #line 1170 "rx-decode.opc" 14747 ID(dmov); DDRL(rdst); SR(rsrc); F_____; 14748 14749 } 14750 break; 14751 case 0x02: 14752 case 0x03: 14753 op_semantics_131: 14754 { 14755 /** 1111 1101 0111 0111 1000 rsrc rdst 001s dmov%s %1, %0 */ 14756 #line 1167 "rx-decode.opc" 14757 int rsrc AU = op[2] & 0x0f; 14758 #line 1167 "rx-decode.opc" 14759 int rdst AU = (op[3] >> 4) & 0x0f; 14760 #line 1167 "rx-decode.opc" 14761 int s AU = op[3] & 0x01; 14762 if (trace) 14763 { 14764 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 14765 "/** 1111 1101 0111 0111 1000 rsrc rdst 001s dmov%s %1, %0 */", 14766 op[0], op[1], op[2], op[3]); 14767 printf (" rsrc = 0x%x,", rsrc); 14768 printf (" rdst = 0x%x,", rdst); 14769 printf (" s = 0x%x\n", s); 14770 } 14771 SYNTAX("dmov%s %1, %0"); 14772 #line 1167 "rx-decode.opc" 14773 ID(dmov); DDRH(rdst); SR(rsrc); DL(s); F_____; 14774 14775 } 14776 break; 14777 case 0x04: 14778 op_semantics_132: 14779 { 14780 /** 1111 1101 0111 0111 1000 rdst rsrc 0100 mvtdc %1, %0 */ 14781 #line 1232 "rx-decode.opc" 14782 int rdst AU = op[2] & 0x0f; 14783 #line 1232 "rx-decode.opc" 14784 int rsrc AU = (op[3] >> 4) & 0x0f; 14785 if (trace) 14786 { 14787 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 14788 "/** 1111 1101 0111 0111 1000 rdst rsrc 0100 mvtdc %1, %0 */", 14789 op[0], op[1], op[2], op[3]); 14790 printf (" rdst = 0x%x,", rdst); 14791 printf (" rsrc = 0x%x\n", rsrc); 14792 } 14793 SYNTAX("mvtdc %1, %0"); 14794 #line 1232 "rx-decode.opc" 14795 ID(mvtdc); DCR(rdst); SR(rsrc); F_____; 14796 14797 } 14798 break; 14799 case 0x09: 14800 op_semantics_133: 14801 { 14802 /** 1111 1101 0111 0111 1000 rsrc rdst 1001 itod %1, %0 */ 14803 #line 1274 "rx-decode.opc" 14804 int rsrc AU = op[2] & 0x0f; 14805 #line 1274 "rx-decode.opc" 14806 int rdst AU = (op[3] >> 4) & 0x0f; 14807 if (trace) 14808 { 14809 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 14810 "/** 1111 1101 0111 0111 1000 rsrc rdst 1001 itod %1, %0 */", 14811 op[0], op[1], op[2], op[3]); 14812 printf (" rsrc = 0x%x,", rsrc); 14813 printf (" rdst = 0x%x\n", rdst); 14814 } 14815 SYNTAX("itod %1, %0"); 14816 #line 1274 "rx-decode.opc" 14817 ID(itod); DDR(rdst); SR(rsrc); F_____; 14818 14819 } 14820 break; 14821 case 0x0a: 14822 op_semantics_134: 14823 { 14824 /** 1111 1101 0111 0111 1000 rsrc rdst 1010 ftod %1, %0 */ 14825 #line 1271 "rx-decode.opc" 14826 int rsrc AU = op[2] & 0x0f; 14827 #line 1271 "rx-decode.opc" 14828 int rdst AU = (op[3] >> 4) & 0x0f; 14829 if (trace) 14830 { 14831 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 14832 "/** 1111 1101 0111 0111 1000 rsrc rdst 1010 ftod %1, %0 */", 14833 op[0], op[1], op[2], op[3]); 14834 printf (" rsrc = 0x%x,", rsrc); 14835 printf (" rdst = 0x%x\n", rdst); 14836 } 14837 SYNTAX("ftod %1, %0"); 14838 #line 1271 "rx-decode.opc" 14839 ID(ftod); DDR(rdst); SR(rsrc); F_____; 14840 14841 } 14842 break; 14843 case 0x0d: 14844 op_semantics_135: 14845 { 14846 /** 1111 1101 0111 0111 1000 rsrc rdst 1101 utod %1, %0 */ 14847 #line 1277 "rx-decode.opc" 14848 int rsrc AU = op[2] & 0x0f; 14849 #line 1277 "rx-decode.opc" 14850 int rdst AU = (op[3] >> 4) & 0x0f; 14851 if (trace) 14852 { 14853 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 14854 "/** 1111 1101 0111 0111 1000 rsrc rdst 1101 utod %1, %0 */", 14855 op[0], op[1], op[2], op[3]); 14856 printf (" rsrc = 0x%x,", rsrc); 14857 printf (" rdst = 0x%x\n", rdst); 14858 } 14859 SYNTAX("utod %1, %0"); 14860 #line 1277 "rx-decode.opc" 14861 ID(dsqrt); DDR(rdst); SR(rsrc); F_____; 14862 14863 } 14864 break; 14865 default: UNSUPPORTED(); break; 14866 } 14867 break; 14868 case 0x81: 14869 GETBYTE (); 14870 switch (op[3] & 0x0f) 14871 { 14872 case 0x00: 14873 goto op_semantics_130; 14874 break; 14875 case 0x02: 14876 case 0x03: 14877 goto op_semantics_131; 14878 break; 14879 case 0x04: 14880 goto op_semantics_132; 14881 break; 14882 case 0x09: 14883 goto op_semantics_133; 14884 break; 14885 case 0x0a: 14886 goto op_semantics_134; 14887 break; 14888 case 0x0d: 14889 goto op_semantics_135; 14890 break; 14891 default: UNSUPPORTED(); break; 14892 } 14893 break; 14894 case 0x82: 14895 GETBYTE (); 14896 switch (op[3] & 0x0f) 14897 { 14898 case 0x00: 14899 goto op_semantics_130; 14900 break; 14901 case 0x02: 14902 case 0x03: 14903 goto op_semantics_131; 14904 break; 14905 case 0x04: 14906 goto op_semantics_132; 14907 break; 14908 case 0x09: 14909 goto op_semantics_133; 14910 break; 14911 case 0x0a: 14912 goto op_semantics_134; 14913 break; 14914 case 0x0d: 14915 goto op_semantics_135; 14916 break; 14917 default: UNSUPPORTED(); break; 14918 } 14919 break; 14920 case 0x83: 14921 GETBYTE (); 14922 switch (op[3] & 0x0f) 14923 { 14924 case 0x00: 14925 goto op_semantics_130; 14926 break; 14927 case 0x02: 14928 case 0x03: 14929 goto op_semantics_131; 14930 break; 14931 case 0x04: 14932 goto op_semantics_132; 14933 break; 14934 case 0x09: 14935 goto op_semantics_133; 14936 break; 14937 case 0x0a: 14938 goto op_semantics_134; 14939 break; 14940 case 0x0d: 14941 goto op_semantics_135; 14942 break; 14943 default: UNSUPPORTED(); break; 14944 } 14945 break; 14946 case 0x84: 14947 GETBYTE (); 14948 switch (op[3] & 0x0f) 14949 { 14950 case 0x00: 14951 goto op_semantics_130; 14952 break; 14953 case 0x02: 14954 case 0x03: 14955 goto op_semantics_131; 14956 break; 14957 case 0x04: 14958 goto op_semantics_132; 14959 break; 14960 case 0x09: 14961 goto op_semantics_133; 14962 break; 14963 case 0x0a: 14964 goto op_semantics_134; 14965 break; 14966 case 0x0d: 14967 goto op_semantics_135; 14968 break; 14969 default: UNSUPPORTED(); break; 14970 } 14971 break; 14972 case 0x85: 14973 GETBYTE (); 14974 switch (op[3] & 0x0f) 14975 { 14976 case 0x00: 14977 goto op_semantics_130; 14978 break; 14979 case 0x02: 14980 case 0x03: 14981 goto op_semantics_131; 14982 break; 14983 case 0x04: 14984 goto op_semantics_132; 14985 break; 14986 case 0x09: 14987 goto op_semantics_133; 14988 break; 14989 case 0x0a: 14990 goto op_semantics_134; 14991 break; 14992 case 0x0d: 14993 goto op_semantics_135; 14994 break; 14995 default: UNSUPPORTED(); break; 14996 } 14997 break; 14998 case 0x86: 14999 GETBYTE (); 15000 switch (op[3] & 0x0f) 15001 { 15002 case 0x00: 15003 goto op_semantics_130; 15004 break; 15005 case 0x02: 15006 case 0x03: 15007 goto op_semantics_131; 15008 break; 15009 case 0x04: 15010 goto op_semantics_132; 15011 break; 15012 case 0x09: 15013 goto op_semantics_133; 15014 break; 15015 case 0x0a: 15016 goto op_semantics_134; 15017 break; 15018 case 0x0d: 15019 goto op_semantics_135; 15020 break; 15021 default: UNSUPPORTED(); break; 15022 } 15023 break; 15024 case 0x87: 15025 GETBYTE (); 15026 switch (op[3] & 0x0f) 15027 { 15028 case 0x00: 15029 goto op_semantics_130; 15030 break; 15031 case 0x02: 15032 case 0x03: 15033 goto op_semantics_131; 15034 break; 15035 case 0x04: 15036 goto op_semantics_132; 15037 break; 15038 case 0x09: 15039 goto op_semantics_133; 15040 break; 15041 case 0x0a: 15042 goto op_semantics_134; 15043 break; 15044 case 0x0d: 15045 goto op_semantics_135; 15046 break; 15047 default: UNSUPPORTED(); break; 15048 } 15049 break; 15050 case 0x88: 15051 GETBYTE (); 15052 switch (op[3] & 0x0f) 15053 { 15054 case 0x00: 15055 goto op_semantics_130; 15056 break; 15057 case 0x02: 15058 case 0x03: 15059 goto op_semantics_131; 15060 break; 15061 case 0x04: 15062 goto op_semantics_132; 15063 break; 15064 case 0x09: 15065 goto op_semantics_133; 15066 break; 15067 case 0x0a: 15068 goto op_semantics_134; 15069 break; 15070 case 0x0d: 15071 goto op_semantics_135; 15072 break; 15073 default: UNSUPPORTED(); break; 15074 } 15075 break; 15076 case 0x89: 15077 GETBYTE (); 15078 switch (op[3] & 0x0f) 15079 { 15080 case 0x00: 15081 goto op_semantics_130; 15082 break; 15083 case 0x02: 15084 case 0x03: 15085 goto op_semantics_131; 15086 break; 15087 case 0x04: 15088 goto op_semantics_132; 15089 break; 15090 case 0x09: 15091 goto op_semantics_133; 15092 break; 15093 case 0x0a: 15094 goto op_semantics_134; 15095 break; 15096 case 0x0d: 15097 goto op_semantics_135; 15098 break; 15099 default: UNSUPPORTED(); break; 15100 } 15101 break; 15102 case 0x8a: 15103 GETBYTE (); 15104 switch (op[3] & 0x0f) 15105 { 15106 case 0x00: 15107 goto op_semantics_130; 15108 break; 15109 case 0x02: 15110 case 0x03: 15111 goto op_semantics_131; 15112 break; 15113 case 0x04: 15114 goto op_semantics_132; 15115 break; 15116 case 0x09: 15117 goto op_semantics_133; 15118 break; 15119 case 0x0a: 15120 goto op_semantics_134; 15121 break; 15122 case 0x0d: 15123 goto op_semantics_135; 15124 break; 15125 default: UNSUPPORTED(); break; 15126 } 15127 break; 15128 case 0x8b: 15129 GETBYTE (); 15130 switch (op[3] & 0x0f) 15131 { 15132 case 0x00: 15133 goto op_semantics_130; 15134 break; 15135 case 0x02: 15136 case 0x03: 15137 goto op_semantics_131; 15138 break; 15139 case 0x04: 15140 goto op_semantics_132; 15141 break; 15142 case 0x09: 15143 goto op_semantics_133; 15144 break; 15145 case 0x0a: 15146 goto op_semantics_134; 15147 break; 15148 case 0x0d: 15149 goto op_semantics_135; 15150 break; 15151 default: UNSUPPORTED(); break; 15152 } 15153 break; 15154 case 0x8c: 15155 GETBYTE (); 15156 switch (op[3] & 0x0f) 15157 { 15158 case 0x00: 15159 goto op_semantics_130; 15160 break; 15161 case 0x02: 15162 case 0x03: 15163 goto op_semantics_131; 15164 break; 15165 case 0x04: 15166 goto op_semantics_132; 15167 break; 15168 case 0x09: 15169 goto op_semantics_133; 15170 break; 15171 case 0x0a: 15172 goto op_semantics_134; 15173 break; 15174 case 0x0d: 15175 goto op_semantics_135; 15176 break; 15177 default: UNSUPPORTED(); break; 15178 } 15179 break; 15180 case 0x8d: 15181 GETBYTE (); 15182 switch (op[3] & 0x0f) 15183 { 15184 case 0x00: 15185 goto op_semantics_130; 15186 break; 15187 case 0x02: 15188 case 0x03: 15189 goto op_semantics_131; 15190 break; 15191 case 0x04: 15192 goto op_semantics_132; 15193 break; 15194 case 0x09: 15195 goto op_semantics_133; 15196 break; 15197 case 0x0a: 15198 goto op_semantics_134; 15199 break; 15200 case 0x0d: 15201 goto op_semantics_135; 15202 break; 15203 default: UNSUPPORTED(); break; 15204 } 15205 break; 15206 case 0x8e: 15207 GETBYTE (); 15208 switch (op[3] & 0x0f) 15209 { 15210 case 0x00: 15211 goto op_semantics_130; 15212 break; 15213 case 0x02: 15214 case 0x03: 15215 goto op_semantics_131; 15216 break; 15217 case 0x04: 15218 goto op_semantics_132; 15219 break; 15220 case 0x09: 15221 goto op_semantics_133; 15222 break; 15223 case 0x0a: 15224 goto op_semantics_134; 15225 break; 15226 case 0x0d: 15227 goto op_semantics_135; 15228 break; 15229 default: UNSUPPORTED(); break; 15230 } 15231 break; 15232 case 0x8f: 15233 GETBYTE (); 15234 switch (op[3] & 0x0f) 15235 { 15236 case 0x00: 15237 goto op_semantics_130; 15238 break; 15239 case 0x02: 15240 case 0x03: 15241 goto op_semantics_131; 15242 break; 15243 case 0x04: 15244 goto op_semantics_132; 15245 break; 15246 case 0x09: 15247 goto op_semantics_133; 15248 break; 15249 case 0x0a: 15250 goto op_semantics_134; 15251 break; 15252 case 0x0d: 15253 goto op_semantics_135; 15254 break; 15255 default: UNSUPPORTED(); break; 15256 } 15257 break; 15258 default: UNSUPPORTED(); break; 15259 } 15260 break; 15261 case 0x78: 15262 GETBYTE (); 15263 switch (op[2] & 0xf0) 15264 { 15265 case 0x20: 15266 goto op_semantics_113; 15267 break; 15268 case 0x40: 15269 goto op_semantics_114; 15270 break; 15271 case 0x50: 15272 goto op_semantics_115; 15273 break; 15274 case 0x60: 15275 goto op_semantics_116; 15276 break; 15277 case 0x70: 15278 goto op_semantics_117; 15279 break; 15280 case 0x80: 15281 goto op_semantics_118; 15282 break; 15283 case 0x90: 15284 goto op_semantics_119; 15285 break; 15286 case 0xc0: 15287 goto op_semantics_120; 15288 break; 15289 case 0xd0: 15290 goto op_semantics_121; 15291 break; 15292 case 0xe0: 15293 goto op_semantics_122; 15294 break; 15295 case 0xf0: 15296 goto op_semantics_123; 15297 break; 15298 default: UNSUPPORTED(); break; 15299 } 15300 break; 15301 case 0x7b: 15302 GETBYTE (); 15303 switch (op[2] & 0xe0) 15304 { 15305 case 0x00: 15306 goto op_semantics_124; 15307 break; 15308 default: UNSUPPORTED(); break; 15309 } 15310 break; 15311 case 0x7c: 15312 GETBYTE (); 15313 switch (op[2] & 0xf0) 15314 { 15315 case 0x20: 15316 goto op_semantics_113; 15317 break; 15318 case 0x40: 15319 goto op_semantics_114; 15320 break; 15321 case 0x50: 15322 goto op_semantics_115; 15323 break; 15324 case 0x60: 15325 goto op_semantics_116; 15326 break; 15327 case 0x70: 15328 goto op_semantics_117; 15329 break; 15330 case 0x80: 15331 goto op_semantics_118; 15332 break; 15333 case 0x90: 15334 goto op_semantics_119; 15335 break; 15336 case 0xc0: 15337 goto op_semantics_120; 15338 break; 15339 case 0xd0: 15340 goto op_semantics_121; 15341 break; 15342 case 0xe0: 15343 goto op_semantics_122; 15344 break; 15345 case 0xf0: 15346 goto op_semantics_123; 15347 break; 15348 default: UNSUPPORTED(); break; 15349 } 15350 break; 15351 case 0x7f: 15352 GETBYTE (); 15353 switch (op[2] & 0xe0) 15354 { 15355 case 0x00: 15356 goto op_semantics_124; 15357 break; 15358 default: UNSUPPORTED(); break; 15359 } 15360 break; 15361 case 0x80: 15362 GETBYTE (); 15363 switch (op[2] & 0x00) 15364 { 15365 case 0x00: 15366 op_semantics_136: 15367 { 15368 /** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */ 15369 #line 757 "rx-decode.opc" 15370 int immmm AU = op[1] & 0x1f; 15371 #line 757 "rx-decode.opc" 15372 int rsrc AU = (op[2] >> 4) & 0x0f; 15373 #line 757 "rx-decode.opc" 15374 int rdst AU = op[2] & 0x0f; 15375 if (trace) 15376 { 15377 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 15378 "/** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */", 15379 op[0], op[1], op[2]); 15380 printf (" immmm = 0x%x,", immmm); 15381 printf (" rsrc = 0x%x,", rsrc); 15382 printf (" rdst = 0x%x\n", rdst); 15383 } 15384 SYNTAX("shlr #%2, %1, %0"); 15385 #line 757 "rx-decode.opc" 15386 ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F__SZC; 15387 15388 /*----------------------------------------------------------------------*/ 15389 /* ROTATE */ 15390 15391 } 15392 break; 15393 } 15394 break; 15395 case 0x81: 15396 GETBYTE (); 15397 switch (op[2] & 0x00) 15398 { 15399 case 0x00: 15400 goto op_semantics_136; 15401 break; 15402 } 15403 break; 15404 case 0x82: 15405 GETBYTE (); 15406 switch (op[2] & 0x00) 15407 { 15408 case 0x00: 15409 goto op_semantics_136; 15410 break; 15411 } 15412 break; 15413 case 0x83: 15414 GETBYTE (); 15415 switch (op[2] & 0x00) 15416 { 15417 case 0x00: 15418 goto op_semantics_136; 15419 break; 15420 } 15421 break; 15422 case 0x84: 15423 GETBYTE (); 15424 switch (op[2] & 0x00) 15425 { 15426 case 0x00: 15427 goto op_semantics_136; 15428 break; 15429 } 15430 break; 15431 case 0x85: 15432 GETBYTE (); 15433 switch (op[2] & 0x00) 15434 { 15435 case 0x00: 15436 goto op_semantics_136; 15437 break; 15438 } 15439 break; 15440 case 0x86: 15441 GETBYTE (); 15442 switch (op[2] & 0x00) 15443 { 15444 case 0x00: 15445 goto op_semantics_136; 15446 break; 15447 } 15448 break; 15449 case 0x87: 15450 GETBYTE (); 15451 switch (op[2] & 0x00) 15452 { 15453 case 0x00: 15454 goto op_semantics_136; 15455 break; 15456 } 15457 break; 15458 case 0x88: 15459 GETBYTE (); 15460 switch (op[2] & 0x00) 15461 { 15462 case 0x00: 15463 goto op_semantics_136; 15464 break; 15465 } 15466 break; 15467 case 0x89: 15468 GETBYTE (); 15469 switch (op[2] & 0x00) 15470 { 15471 case 0x00: 15472 goto op_semantics_136; 15473 break; 15474 } 15475 break; 15476 case 0x8a: 15477 GETBYTE (); 15478 switch (op[2] & 0x00) 15479 { 15480 case 0x00: 15481 goto op_semantics_136; 15482 break; 15483 } 15484 break; 15485 case 0x8b: 15486 GETBYTE (); 15487 switch (op[2] & 0x00) 15488 { 15489 case 0x00: 15490 goto op_semantics_136; 15491 break; 15492 } 15493 break; 15494 case 0x8c: 15495 GETBYTE (); 15496 switch (op[2] & 0x00) 15497 { 15498 case 0x00: 15499 goto op_semantics_136; 15500 break; 15501 } 15502 break; 15503 case 0x8d: 15504 GETBYTE (); 15505 switch (op[2] & 0x00) 15506 { 15507 case 0x00: 15508 goto op_semantics_136; 15509 break; 15510 } 15511 break; 15512 case 0x8e: 15513 GETBYTE (); 15514 switch (op[2] & 0x00) 15515 { 15516 case 0x00: 15517 goto op_semantics_136; 15518 break; 15519 } 15520 break; 15521 case 0x8f: 15522 GETBYTE (); 15523 switch (op[2] & 0x00) 15524 { 15525 case 0x00: 15526 goto op_semantics_136; 15527 break; 15528 } 15529 break; 15530 case 0x90: 15531 GETBYTE (); 15532 switch (op[2] & 0x00) 15533 { 15534 case 0x00: 15535 goto op_semantics_136; 15536 break; 15537 } 15538 break; 15539 case 0x91: 15540 GETBYTE (); 15541 switch (op[2] & 0x00) 15542 { 15543 case 0x00: 15544 goto op_semantics_136; 15545 break; 15546 } 15547 break; 15548 case 0x92: 15549 GETBYTE (); 15550 switch (op[2] & 0x00) 15551 { 15552 case 0x00: 15553 goto op_semantics_136; 15554 break; 15555 } 15556 break; 15557 case 0x93: 15558 GETBYTE (); 15559 switch (op[2] & 0x00) 15560 { 15561 case 0x00: 15562 goto op_semantics_136; 15563 break; 15564 } 15565 break; 15566 case 0x94: 15567 GETBYTE (); 15568 switch (op[2] & 0x00) 15569 { 15570 case 0x00: 15571 goto op_semantics_136; 15572 break; 15573 } 15574 break; 15575 case 0x95: 15576 GETBYTE (); 15577 switch (op[2] & 0x00) 15578 { 15579 case 0x00: 15580 goto op_semantics_136; 15581 break; 15582 } 15583 break; 15584 case 0x96: 15585 GETBYTE (); 15586 switch (op[2] & 0x00) 15587 { 15588 case 0x00: 15589 goto op_semantics_136; 15590 break; 15591 } 15592 break; 15593 case 0x97: 15594 GETBYTE (); 15595 switch (op[2] & 0x00) 15596 { 15597 case 0x00: 15598 goto op_semantics_136; 15599 break; 15600 } 15601 break; 15602 case 0x98: 15603 GETBYTE (); 15604 switch (op[2] & 0x00) 15605 { 15606 case 0x00: 15607 goto op_semantics_136; 15608 break; 15609 } 15610 break; 15611 case 0x99: 15612 GETBYTE (); 15613 switch (op[2] & 0x00) 15614 { 15615 case 0x00: 15616 goto op_semantics_136; 15617 break; 15618 } 15619 break; 15620 case 0x9a: 15621 GETBYTE (); 15622 switch (op[2] & 0x00) 15623 { 15624 case 0x00: 15625 goto op_semantics_136; 15626 break; 15627 } 15628 break; 15629 case 0x9b: 15630 GETBYTE (); 15631 switch (op[2] & 0x00) 15632 { 15633 case 0x00: 15634 goto op_semantics_136; 15635 break; 15636 } 15637 break; 15638 case 0x9c: 15639 GETBYTE (); 15640 switch (op[2] & 0x00) 15641 { 15642 case 0x00: 15643 goto op_semantics_136; 15644 break; 15645 } 15646 break; 15647 case 0x9d: 15648 GETBYTE (); 15649 switch (op[2] & 0x00) 15650 { 15651 case 0x00: 15652 goto op_semantics_136; 15653 break; 15654 } 15655 break; 15656 case 0x9e: 15657 GETBYTE (); 15658 switch (op[2] & 0x00) 15659 { 15660 case 0x00: 15661 goto op_semantics_136; 15662 break; 15663 } 15664 break; 15665 case 0x9f: 15666 GETBYTE (); 15667 switch (op[2] & 0x00) 15668 { 15669 case 0x00: 15670 goto op_semantics_136; 15671 break; 15672 } 15673 break; 15674 case 0xa0: 15675 GETBYTE (); 15676 switch (op[2] & 0x00) 15677 { 15678 case 0x00: 15679 op_semantics_137: 15680 { 15681 /** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */ 15682 #line 747 "rx-decode.opc" 15683 int immmm AU = op[1] & 0x1f; 15684 #line 747 "rx-decode.opc" 15685 int rsrc AU = (op[2] >> 4) & 0x0f; 15686 #line 747 "rx-decode.opc" 15687 int rdst AU = op[2] & 0x0f; 15688 if (trace) 15689 { 15690 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 15691 "/** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */", 15692 op[0], op[1], op[2]); 15693 printf (" immmm = 0x%x,", immmm); 15694 printf (" rsrc = 0x%x,", rsrc); 15695 printf (" rdst = 0x%x\n", rdst); 15696 } 15697 SYNTAX("shar #%2, %1, %0"); 15698 #line 747 "rx-decode.opc" 15699 ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F_0SZC; 15700 15701 15702 } 15703 break; 15704 } 15705 break; 15706 case 0xa1: 15707 GETBYTE (); 15708 switch (op[2] & 0x00) 15709 { 15710 case 0x00: 15711 goto op_semantics_137; 15712 break; 15713 } 15714 break; 15715 case 0xa2: 15716 GETBYTE (); 15717 switch (op[2] & 0x00) 15718 { 15719 case 0x00: 15720 goto op_semantics_137; 15721 break; 15722 } 15723 break; 15724 case 0xa3: 15725 GETBYTE (); 15726 switch (op[2] & 0x00) 15727 { 15728 case 0x00: 15729 goto op_semantics_137; 15730 break; 15731 } 15732 break; 15733 case 0xa4: 15734 GETBYTE (); 15735 switch (op[2] & 0x00) 15736 { 15737 case 0x00: 15738 goto op_semantics_137; 15739 break; 15740 } 15741 break; 15742 case 0xa5: 15743 GETBYTE (); 15744 switch (op[2] & 0x00) 15745 { 15746 case 0x00: 15747 goto op_semantics_137; 15748 break; 15749 } 15750 break; 15751 case 0xa6: 15752 GETBYTE (); 15753 switch (op[2] & 0x00) 15754 { 15755 case 0x00: 15756 goto op_semantics_137; 15757 break; 15758 } 15759 break; 15760 case 0xa7: 15761 GETBYTE (); 15762 switch (op[2] & 0x00) 15763 { 15764 case 0x00: 15765 goto op_semantics_137; 15766 break; 15767 } 15768 break; 15769 case 0xa8: 15770 GETBYTE (); 15771 switch (op[2] & 0x00) 15772 { 15773 case 0x00: 15774 goto op_semantics_137; 15775 break; 15776 } 15777 break; 15778 case 0xa9: 15779 GETBYTE (); 15780 switch (op[2] & 0x00) 15781 { 15782 case 0x00: 15783 goto op_semantics_137; 15784 break; 15785 } 15786 break; 15787 case 0xaa: 15788 GETBYTE (); 15789 switch (op[2] & 0x00) 15790 { 15791 case 0x00: 15792 goto op_semantics_137; 15793 break; 15794 } 15795 break; 15796 case 0xab: 15797 GETBYTE (); 15798 switch (op[2] & 0x00) 15799 { 15800 case 0x00: 15801 goto op_semantics_137; 15802 break; 15803 } 15804 break; 15805 case 0xac: 15806 GETBYTE (); 15807 switch (op[2] & 0x00) 15808 { 15809 case 0x00: 15810 goto op_semantics_137; 15811 break; 15812 } 15813 break; 15814 case 0xad: 15815 GETBYTE (); 15816 switch (op[2] & 0x00) 15817 { 15818 case 0x00: 15819 goto op_semantics_137; 15820 break; 15821 } 15822 break; 15823 case 0xae: 15824 GETBYTE (); 15825 switch (op[2] & 0x00) 15826 { 15827 case 0x00: 15828 goto op_semantics_137; 15829 break; 15830 } 15831 break; 15832 case 0xaf: 15833 GETBYTE (); 15834 switch (op[2] & 0x00) 15835 { 15836 case 0x00: 15837 goto op_semantics_137; 15838 break; 15839 } 15840 break; 15841 case 0xb0: 15842 GETBYTE (); 15843 switch (op[2] & 0x00) 15844 { 15845 case 0x00: 15846 goto op_semantics_137; 15847 break; 15848 } 15849 break; 15850 case 0xb1: 15851 GETBYTE (); 15852 switch (op[2] & 0x00) 15853 { 15854 case 0x00: 15855 goto op_semantics_137; 15856 break; 15857 } 15858 break; 15859 case 0xb2: 15860 GETBYTE (); 15861 switch (op[2] & 0x00) 15862 { 15863 case 0x00: 15864 goto op_semantics_137; 15865 break; 15866 } 15867 break; 15868 case 0xb3: 15869 GETBYTE (); 15870 switch (op[2] & 0x00) 15871 { 15872 case 0x00: 15873 goto op_semantics_137; 15874 break; 15875 } 15876 break; 15877 case 0xb4: 15878 GETBYTE (); 15879 switch (op[2] & 0x00) 15880 { 15881 case 0x00: 15882 goto op_semantics_137; 15883 break; 15884 } 15885 break; 15886 case 0xb5: 15887 GETBYTE (); 15888 switch (op[2] & 0x00) 15889 { 15890 case 0x00: 15891 goto op_semantics_137; 15892 break; 15893 } 15894 break; 15895 case 0xb6: 15896 GETBYTE (); 15897 switch (op[2] & 0x00) 15898 { 15899 case 0x00: 15900 goto op_semantics_137; 15901 break; 15902 } 15903 break; 15904 case 0xb7: 15905 GETBYTE (); 15906 switch (op[2] & 0x00) 15907 { 15908 case 0x00: 15909 goto op_semantics_137; 15910 break; 15911 } 15912 break; 15913 case 0xb8: 15914 GETBYTE (); 15915 switch (op[2] & 0x00) 15916 { 15917 case 0x00: 15918 goto op_semantics_137; 15919 break; 15920 } 15921 break; 15922 case 0xb9: 15923 GETBYTE (); 15924 switch (op[2] & 0x00) 15925 { 15926 case 0x00: 15927 goto op_semantics_137; 15928 break; 15929 } 15930 break; 15931 case 0xba: 15932 GETBYTE (); 15933 switch (op[2] & 0x00) 15934 { 15935 case 0x00: 15936 goto op_semantics_137; 15937 break; 15938 } 15939 break; 15940 case 0xbb: 15941 GETBYTE (); 15942 switch (op[2] & 0x00) 15943 { 15944 case 0x00: 15945 goto op_semantics_137; 15946 break; 15947 } 15948 break; 15949 case 0xbc: 15950 GETBYTE (); 15951 switch (op[2] & 0x00) 15952 { 15953 case 0x00: 15954 goto op_semantics_137; 15955 break; 15956 } 15957 break; 15958 case 0xbd: 15959 GETBYTE (); 15960 switch (op[2] & 0x00) 15961 { 15962 case 0x00: 15963 goto op_semantics_137; 15964 break; 15965 } 15966 break; 15967 case 0xbe: 15968 GETBYTE (); 15969 switch (op[2] & 0x00) 15970 { 15971 case 0x00: 15972 goto op_semantics_137; 15973 break; 15974 } 15975 break; 15976 case 0xbf: 15977 GETBYTE (); 15978 switch (op[2] & 0x00) 15979 { 15980 case 0x00: 15981 goto op_semantics_137; 15982 break; 15983 } 15984 break; 15985 case 0xc0: 15986 GETBYTE (); 15987 switch (op[2] & 0x00) 15988 { 15989 case 0x00: 15990 op_semantics_138: 15991 { 15992 /** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */ 15993 #line 737 "rx-decode.opc" 15994 int immmm AU = op[1] & 0x1f; 15995 #line 737 "rx-decode.opc" 15996 int rsrc AU = (op[2] >> 4) & 0x0f; 15997 #line 737 "rx-decode.opc" 15998 int rdst AU = op[2] & 0x0f; 15999 if (trace) 16000 { 16001 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 16002 "/** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */", 16003 op[0], op[1], op[2]); 16004 printf (" immmm = 0x%x,", immmm); 16005 printf (" rsrc = 0x%x,", rsrc); 16006 printf (" rdst = 0x%x\n", rdst); 16007 } 16008 SYNTAX("shll #%2, %1, %0"); 16009 #line 737 "rx-decode.opc" 16010 ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F_OSZC; 16011 16012 16013 } 16014 break; 16015 } 16016 break; 16017 case 0xc1: 16018 GETBYTE (); 16019 switch (op[2] & 0x00) 16020 { 16021 case 0x00: 16022 goto op_semantics_138; 16023 break; 16024 } 16025 break; 16026 case 0xc2: 16027 GETBYTE (); 16028 switch (op[2] & 0x00) 16029 { 16030 case 0x00: 16031 goto op_semantics_138; 16032 break; 16033 } 16034 break; 16035 case 0xc3: 16036 GETBYTE (); 16037 switch (op[2] & 0x00) 16038 { 16039 case 0x00: 16040 goto op_semantics_138; 16041 break; 16042 } 16043 break; 16044 case 0xc4: 16045 GETBYTE (); 16046 switch (op[2] & 0x00) 16047 { 16048 case 0x00: 16049 goto op_semantics_138; 16050 break; 16051 } 16052 break; 16053 case 0xc5: 16054 GETBYTE (); 16055 switch (op[2] & 0x00) 16056 { 16057 case 0x00: 16058 goto op_semantics_138; 16059 break; 16060 } 16061 break; 16062 case 0xc6: 16063 GETBYTE (); 16064 switch (op[2] & 0x00) 16065 { 16066 case 0x00: 16067 goto op_semantics_138; 16068 break; 16069 } 16070 break; 16071 case 0xc7: 16072 GETBYTE (); 16073 switch (op[2] & 0x00) 16074 { 16075 case 0x00: 16076 goto op_semantics_138; 16077 break; 16078 } 16079 break; 16080 case 0xc8: 16081 GETBYTE (); 16082 switch (op[2] & 0x00) 16083 { 16084 case 0x00: 16085 goto op_semantics_138; 16086 break; 16087 } 16088 break; 16089 case 0xc9: 16090 GETBYTE (); 16091 switch (op[2] & 0x00) 16092 { 16093 case 0x00: 16094 goto op_semantics_138; 16095 break; 16096 } 16097 break; 16098 case 0xca: 16099 GETBYTE (); 16100 switch (op[2] & 0x00) 16101 { 16102 case 0x00: 16103 goto op_semantics_138; 16104 break; 16105 } 16106 break; 16107 case 0xcb: 16108 GETBYTE (); 16109 switch (op[2] & 0x00) 16110 { 16111 case 0x00: 16112 goto op_semantics_138; 16113 break; 16114 } 16115 break; 16116 case 0xcc: 16117 GETBYTE (); 16118 switch (op[2] & 0x00) 16119 { 16120 case 0x00: 16121 goto op_semantics_138; 16122 break; 16123 } 16124 break; 16125 case 0xcd: 16126 GETBYTE (); 16127 switch (op[2] & 0x00) 16128 { 16129 case 0x00: 16130 goto op_semantics_138; 16131 break; 16132 } 16133 break; 16134 case 0xce: 16135 GETBYTE (); 16136 switch (op[2] & 0x00) 16137 { 16138 case 0x00: 16139 goto op_semantics_138; 16140 break; 16141 } 16142 break; 16143 case 0xcf: 16144 GETBYTE (); 16145 switch (op[2] & 0x00) 16146 { 16147 case 0x00: 16148 goto op_semantics_138; 16149 break; 16150 } 16151 break; 16152 case 0xd0: 16153 GETBYTE (); 16154 switch (op[2] & 0x00) 16155 { 16156 case 0x00: 16157 goto op_semantics_138; 16158 break; 16159 } 16160 break; 16161 case 0xd1: 16162 GETBYTE (); 16163 switch (op[2] & 0x00) 16164 { 16165 case 0x00: 16166 goto op_semantics_138; 16167 break; 16168 } 16169 break; 16170 case 0xd2: 16171 GETBYTE (); 16172 switch (op[2] & 0x00) 16173 { 16174 case 0x00: 16175 goto op_semantics_138; 16176 break; 16177 } 16178 break; 16179 case 0xd3: 16180 GETBYTE (); 16181 switch (op[2] & 0x00) 16182 { 16183 case 0x00: 16184 goto op_semantics_138; 16185 break; 16186 } 16187 break; 16188 case 0xd4: 16189 GETBYTE (); 16190 switch (op[2] & 0x00) 16191 { 16192 case 0x00: 16193 goto op_semantics_138; 16194 break; 16195 } 16196 break; 16197 case 0xd5: 16198 GETBYTE (); 16199 switch (op[2] & 0x00) 16200 { 16201 case 0x00: 16202 goto op_semantics_138; 16203 break; 16204 } 16205 break; 16206 case 0xd6: 16207 GETBYTE (); 16208 switch (op[2] & 0x00) 16209 { 16210 case 0x00: 16211 goto op_semantics_138; 16212 break; 16213 } 16214 break; 16215 case 0xd7: 16216 GETBYTE (); 16217 switch (op[2] & 0x00) 16218 { 16219 case 0x00: 16220 goto op_semantics_138; 16221 break; 16222 } 16223 break; 16224 case 0xd8: 16225 GETBYTE (); 16226 switch (op[2] & 0x00) 16227 { 16228 case 0x00: 16229 goto op_semantics_138; 16230 break; 16231 } 16232 break; 16233 case 0xd9: 16234 GETBYTE (); 16235 switch (op[2] & 0x00) 16236 { 16237 case 0x00: 16238 goto op_semantics_138; 16239 break; 16240 } 16241 break; 16242 case 0xda: 16243 GETBYTE (); 16244 switch (op[2] & 0x00) 16245 { 16246 case 0x00: 16247 goto op_semantics_138; 16248 break; 16249 } 16250 break; 16251 case 0xdb: 16252 GETBYTE (); 16253 switch (op[2] & 0x00) 16254 { 16255 case 0x00: 16256 goto op_semantics_138; 16257 break; 16258 } 16259 break; 16260 case 0xdc: 16261 GETBYTE (); 16262 switch (op[2] & 0x00) 16263 { 16264 case 0x00: 16265 goto op_semantics_138; 16266 break; 16267 } 16268 break; 16269 case 0xdd: 16270 GETBYTE (); 16271 switch (op[2] & 0x00) 16272 { 16273 case 0x00: 16274 goto op_semantics_138; 16275 break; 16276 } 16277 break; 16278 case 0xde: 16279 GETBYTE (); 16280 switch (op[2] & 0x00) 16281 { 16282 case 0x00: 16283 goto op_semantics_138; 16284 break; 16285 } 16286 break; 16287 case 0xdf: 16288 GETBYTE (); 16289 switch (op[2] & 0x00) 16290 { 16291 case 0x00: 16292 goto op_semantics_138; 16293 break; 16294 } 16295 break; 16296 case 0xe0: 16297 GETBYTE (); 16298 switch (op[2] & 0xf0) 16299 { 16300 case 0x00: 16301 case 0x10: 16302 case 0x20: 16303 case 0x30: 16304 case 0x40: 16305 case 0x50: 16306 case 0x60: 16307 case 0x70: 16308 case 0x80: 16309 case 0x90: 16310 case 0xa0: 16311 case 0xb0: 16312 case 0xc0: 16313 case 0xd0: 16314 case 0xe0: 16315 op_semantics_139: 16316 { 16317 /** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */ 16318 #line 1011 "rx-decode.opc" 16319 int bittt AU = op[1] & 0x1f; 16320 #line 1011 "rx-decode.opc" 16321 int cond AU = (op[2] >> 4) & 0x0f; 16322 #line 1011 "rx-decode.opc" 16323 int rdst AU = op[2] & 0x0f; 16324 if (trace) 16325 { 16326 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 16327 "/** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */", 16328 op[0], op[1], op[2]); 16329 printf (" bittt = 0x%x,", bittt); 16330 printf (" cond = 0x%x,", cond); 16331 printf (" rdst = 0x%x\n", rdst); 16332 } 16333 SYNTAX("bm%2 #%1, %0%S0"); 16334 #line 1011 "rx-decode.opc" 16335 ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst); 16336 16337 /*----------------------------------------------------------------------*/ 16338 /* CONTROL REGISTERS */ 16339 16340 } 16341 break; 16342 case 0xf0: 16343 op_semantics_140: 16344 { 16345 /** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */ 16346 #line 1004 "rx-decode.opc" 16347 int bittt AU = op[1] & 0x1f; 16348 #line 1004 "rx-decode.opc" 16349 int rdst AU = op[2] & 0x0f; 16350 if (trace) 16351 { 16352 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 16353 "/** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */", 16354 op[0], op[1], op[2]); 16355 printf (" bittt = 0x%x,", bittt); 16356 printf (" rdst = 0x%x\n", rdst); 16357 } 16358 SYNTAX("bnot #%1, %0"); 16359 #line 1004 "rx-decode.opc" 16360 ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst); 16361 16362 16363 } 16364 break; 16365 } 16366 break; 16367 case 0xe1: 16368 GETBYTE (); 16369 switch (op[2] & 0xf0) 16370 { 16371 case 0x00: 16372 case 0x10: 16373 case 0x20: 16374 case 0x30: 16375 case 0x40: 16376 case 0x50: 16377 case 0x60: 16378 case 0x70: 16379 case 0x80: 16380 case 0x90: 16381 case 0xa0: 16382 case 0xb0: 16383 case 0xc0: 16384 case 0xd0: 16385 case 0xe0: 16386 goto op_semantics_139; 16387 break; 16388 case 0xf0: 16389 goto op_semantics_140; 16390 break; 16391 } 16392 break; 16393 case 0xe2: 16394 GETBYTE (); 16395 switch (op[2] & 0xf0) 16396 { 16397 case 0x00: 16398 case 0x10: 16399 case 0x20: 16400 case 0x30: 16401 case 0x40: 16402 case 0x50: 16403 case 0x60: 16404 case 0x70: 16405 case 0x80: 16406 case 0x90: 16407 case 0xa0: 16408 case 0xb0: 16409 case 0xc0: 16410 case 0xd0: 16411 case 0xe0: 16412 goto op_semantics_139; 16413 break; 16414 case 0xf0: 16415 goto op_semantics_140; 16416 break; 16417 } 16418 break; 16419 case 0xe3: 16420 GETBYTE (); 16421 switch (op[2] & 0xf0) 16422 { 16423 case 0x00: 16424 case 0x10: 16425 case 0x20: 16426 case 0x30: 16427 case 0x40: 16428 case 0x50: 16429 case 0x60: 16430 case 0x70: 16431 case 0x80: 16432 case 0x90: 16433 case 0xa0: 16434 case 0xb0: 16435 case 0xc0: 16436 case 0xd0: 16437 case 0xe0: 16438 goto op_semantics_139; 16439 break; 16440 case 0xf0: 16441 goto op_semantics_140; 16442 break; 16443 } 16444 break; 16445 case 0xe4: 16446 GETBYTE (); 16447 switch (op[2] & 0xf0) 16448 { 16449 case 0x00: 16450 case 0x10: 16451 case 0x20: 16452 case 0x30: 16453 case 0x40: 16454 case 0x50: 16455 case 0x60: 16456 case 0x70: 16457 case 0x80: 16458 case 0x90: 16459 case 0xa0: 16460 case 0xb0: 16461 case 0xc0: 16462 case 0xd0: 16463 case 0xe0: 16464 goto op_semantics_139; 16465 break; 16466 case 0xf0: 16467 goto op_semantics_140; 16468 break; 16469 } 16470 break; 16471 case 0xe5: 16472 GETBYTE (); 16473 switch (op[2] & 0xf0) 16474 { 16475 case 0x00: 16476 case 0x10: 16477 case 0x20: 16478 case 0x30: 16479 case 0x40: 16480 case 0x50: 16481 case 0x60: 16482 case 0x70: 16483 case 0x80: 16484 case 0x90: 16485 case 0xa0: 16486 case 0xb0: 16487 case 0xc0: 16488 case 0xd0: 16489 case 0xe0: 16490 goto op_semantics_139; 16491 break; 16492 case 0xf0: 16493 goto op_semantics_140; 16494 break; 16495 } 16496 break; 16497 case 0xe6: 16498 GETBYTE (); 16499 switch (op[2] & 0xf0) 16500 { 16501 case 0x00: 16502 case 0x10: 16503 case 0x20: 16504 case 0x30: 16505 case 0x40: 16506 case 0x50: 16507 case 0x60: 16508 case 0x70: 16509 case 0x80: 16510 case 0x90: 16511 case 0xa0: 16512 case 0xb0: 16513 case 0xc0: 16514 case 0xd0: 16515 case 0xe0: 16516 goto op_semantics_139; 16517 break; 16518 case 0xf0: 16519 goto op_semantics_140; 16520 break; 16521 } 16522 break; 16523 case 0xe7: 16524 GETBYTE (); 16525 switch (op[2] & 0xf0) 16526 { 16527 case 0x00: 16528 case 0x10: 16529 case 0x20: 16530 case 0x30: 16531 case 0x40: 16532 case 0x50: 16533 case 0x60: 16534 case 0x70: 16535 case 0x80: 16536 case 0x90: 16537 case 0xa0: 16538 case 0xb0: 16539 case 0xc0: 16540 case 0xd0: 16541 case 0xe0: 16542 goto op_semantics_139; 16543 break; 16544 case 0xf0: 16545 goto op_semantics_140; 16546 break; 16547 } 16548 break; 16549 case 0xe8: 16550 GETBYTE (); 16551 switch (op[2] & 0xf0) 16552 { 16553 case 0x00: 16554 case 0x10: 16555 case 0x20: 16556 case 0x30: 16557 case 0x40: 16558 case 0x50: 16559 case 0x60: 16560 case 0x70: 16561 case 0x80: 16562 case 0x90: 16563 case 0xa0: 16564 case 0xb0: 16565 case 0xc0: 16566 case 0xd0: 16567 case 0xe0: 16568 goto op_semantics_139; 16569 break; 16570 case 0xf0: 16571 goto op_semantics_140; 16572 break; 16573 } 16574 break; 16575 case 0xe9: 16576 GETBYTE (); 16577 switch (op[2] & 0xf0) 16578 { 16579 case 0x00: 16580 case 0x10: 16581 case 0x20: 16582 case 0x30: 16583 case 0x40: 16584 case 0x50: 16585 case 0x60: 16586 case 0x70: 16587 case 0x80: 16588 case 0x90: 16589 case 0xa0: 16590 case 0xb0: 16591 case 0xc0: 16592 case 0xd0: 16593 case 0xe0: 16594 goto op_semantics_139; 16595 break; 16596 case 0xf0: 16597 goto op_semantics_140; 16598 break; 16599 } 16600 break; 16601 case 0xea: 16602 GETBYTE (); 16603 switch (op[2] & 0xf0) 16604 { 16605 case 0x00: 16606 case 0x10: 16607 case 0x20: 16608 case 0x30: 16609 case 0x40: 16610 case 0x50: 16611 case 0x60: 16612 case 0x70: 16613 case 0x80: 16614 case 0x90: 16615 case 0xa0: 16616 case 0xb0: 16617 case 0xc0: 16618 case 0xd0: 16619 case 0xe0: 16620 goto op_semantics_139; 16621 break; 16622 case 0xf0: 16623 goto op_semantics_140; 16624 break; 16625 } 16626 break; 16627 case 0xeb: 16628 GETBYTE (); 16629 switch (op[2] & 0xf0) 16630 { 16631 case 0x00: 16632 case 0x10: 16633 case 0x20: 16634 case 0x30: 16635 case 0x40: 16636 case 0x50: 16637 case 0x60: 16638 case 0x70: 16639 case 0x80: 16640 case 0x90: 16641 case 0xa0: 16642 case 0xb0: 16643 case 0xc0: 16644 case 0xd0: 16645 case 0xe0: 16646 goto op_semantics_139; 16647 break; 16648 case 0xf0: 16649 goto op_semantics_140; 16650 break; 16651 } 16652 break; 16653 case 0xec: 16654 GETBYTE (); 16655 switch (op[2] & 0xf0) 16656 { 16657 case 0x00: 16658 case 0x10: 16659 case 0x20: 16660 case 0x30: 16661 case 0x40: 16662 case 0x50: 16663 case 0x60: 16664 case 0x70: 16665 case 0x80: 16666 case 0x90: 16667 case 0xa0: 16668 case 0xb0: 16669 case 0xc0: 16670 case 0xd0: 16671 case 0xe0: 16672 goto op_semantics_139; 16673 break; 16674 case 0xf0: 16675 goto op_semantics_140; 16676 break; 16677 } 16678 break; 16679 case 0xed: 16680 GETBYTE (); 16681 switch (op[2] & 0xf0) 16682 { 16683 case 0x00: 16684 case 0x10: 16685 case 0x20: 16686 case 0x30: 16687 case 0x40: 16688 case 0x50: 16689 case 0x60: 16690 case 0x70: 16691 case 0x80: 16692 case 0x90: 16693 case 0xa0: 16694 case 0xb0: 16695 case 0xc0: 16696 case 0xd0: 16697 case 0xe0: 16698 goto op_semantics_139; 16699 break; 16700 case 0xf0: 16701 goto op_semantics_140; 16702 break; 16703 } 16704 break; 16705 case 0xee: 16706 GETBYTE (); 16707 switch (op[2] & 0xf0) 16708 { 16709 case 0x00: 16710 case 0x10: 16711 case 0x20: 16712 case 0x30: 16713 case 0x40: 16714 case 0x50: 16715 case 0x60: 16716 case 0x70: 16717 case 0x80: 16718 case 0x90: 16719 case 0xa0: 16720 case 0xb0: 16721 case 0xc0: 16722 case 0xd0: 16723 case 0xe0: 16724 goto op_semantics_139; 16725 break; 16726 case 0xf0: 16727 goto op_semantics_140; 16728 break; 16729 } 16730 break; 16731 case 0xef: 16732 GETBYTE (); 16733 switch (op[2] & 0xf0) 16734 { 16735 case 0x00: 16736 case 0x10: 16737 case 0x20: 16738 case 0x30: 16739 case 0x40: 16740 case 0x50: 16741 case 0x60: 16742 case 0x70: 16743 case 0x80: 16744 case 0x90: 16745 case 0xa0: 16746 case 0xb0: 16747 case 0xc0: 16748 case 0xd0: 16749 case 0xe0: 16750 goto op_semantics_139; 16751 break; 16752 case 0xf0: 16753 goto op_semantics_140; 16754 break; 16755 } 16756 break; 16757 case 0xf0: 16758 GETBYTE (); 16759 switch (op[2] & 0xf0) 16760 { 16761 case 0x00: 16762 case 0x10: 16763 case 0x20: 16764 case 0x30: 16765 case 0x40: 16766 case 0x50: 16767 case 0x60: 16768 case 0x70: 16769 case 0x80: 16770 case 0x90: 16771 case 0xa0: 16772 case 0xb0: 16773 case 0xc0: 16774 case 0xd0: 16775 case 0xe0: 16776 goto op_semantics_139; 16777 break; 16778 case 0xf0: 16779 goto op_semantics_140; 16780 break; 16781 } 16782 break; 16783 case 0xf1: 16784 GETBYTE (); 16785 switch (op[2] & 0xf0) 16786 { 16787 case 0x00: 16788 case 0x10: 16789 case 0x20: 16790 case 0x30: 16791 case 0x40: 16792 case 0x50: 16793 case 0x60: 16794 case 0x70: 16795 case 0x80: 16796 case 0x90: 16797 case 0xa0: 16798 case 0xb0: 16799 case 0xc0: 16800 case 0xd0: 16801 case 0xe0: 16802 goto op_semantics_139; 16803 break; 16804 case 0xf0: 16805 goto op_semantics_140; 16806 break; 16807 } 16808 break; 16809 case 0xf2: 16810 GETBYTE (); 16811 switch (op[2] & 0xf0) 16812 { 16813 case 0x00: 16814 case 0x10: 16815 case 0x20: 16816 case 0x30: 16817 case 0x40: 16818 case 0x50: 16819 case 0x60: 16820 case 0x70: 16821 case 0x80: 16822 case 0x90: 16823 case 0xa0: 16824 case 0xb0: 16825 case 0xc0: 16826 case 0xd0: 16827 case 0xe0: 16828 goto op_semantics_139; 16829 break; 16830 case 0xf0: 16831 goto op_semantics_140; 16832 break; 16833 } 16834 break; 16835 case 0xf3: 16836 GETBYTE (); 16837 switch (op[2] & 0xf0) 16838 { 16839 case 0x00: 16840 case 0x10: 16841 case 0x20: 16842 case 0x30: 16843 case 0x40: 16844 case 0x50: 16845 case 0x60: 16846 case 0x70: 16847 case 0x80: 16848 case 0x90: 16849 case 0xa0: 16850 case 0xb0: 16851 case 0xc0: 16852 case 0xd0: 16853 case 0xe0: 16854 goto op_semantics_139; 16855 break; 16856 case 0xf0: 16857 goto op_semantics_140; 16858 break; 16859 } 16860 break; 16861 case 0xf4: 16862 GETBYTE (); 16863 switch (op[2] & 0xf0) 16864 { 16865 case 0x00: 16866 case 0x10: 16867 case 0x20: 16868 case 0x30: 16869 case 0x40: 16870 case 0x50: 16871 case 0x60: 16872 case 0x70: 16873 case 0x80: 16874 case 0x90: 16875 case 0xa0: 16876 case 0xb0: 16877 case 0xc0: 16878 case 0xd0: 16879 case 0xe0: 16880 goto op_semantics_139; 16881 break; 16882 case 0xf0: 16883 goto op_semantics_140; 16884 break; 16885 } 16886 break; 16887 case 0xf5: 16888 GETBYTE (); 16889 switch (op[2] & 0xf0) 16890 { 16891 case 0x00: 16892 case 0x10: 16893 case 0x20: 16894 case 0x30: 16895 case 0x40: 16896 case 0x50: 16897 case 0x60: 16898 case 0x70: 16899 case 0x80: 16900 case 0x90: 16901 case 0xa0: 16902 case 0xb0: 16903 case 0xc0: 16904 case 0xd0: 16905 case 0xe0: 16906 goto op_semantics_139; 16907 break; 16908 case 0xf0: 16909 goto op_semantics_140; 16910 break; 16911 } 16912 break; 16913 case 0xf6: 16914 GETBYTE (); 16915 switch (op[2] & 0xf0) 16916 { 16917 case 0x00: 16918 case 0x10: 16919 case 0x20: 16920 case 0x30: 16921 case 0x40: 16922 case 0x50: 16923 case 0x60: 16924 case 0x70: 16925 case 0x80: 16926 case 0x90: 16927 case 0xa0: 16928 case 0xb0: 16929 case 0xc0: 16930 case 0xd0: 16931 case 0xe0: 16932 goto op_semantics_139; 16933 break; 16934 case 0xf0: 16935 goto op_semantics_140; 16936 break; 16937 } 16938 break; 16939 case 0xf7: 16940 GETBYTE (); 16941 switch (op[2] & 0xf0) 16942 { 16943 case 0x00: 16944 case 0x10: 16945 case 0x20: 16946 case 0x30: 16947 case 0x40: 16948 case 0x50: 16949 case 0x60: 16950 case 0x70: 16951 case 0x80: 16952 case 0x90: 16953 case 0xa0: 16954 case 0xb0: 16955 case 0xc0: 16956 case 0xd0: 16957 case 0xe0: 16958 goto op_semantics_139; 16959 break; 16960 case 0xf0: 16961 goto op_semantics_140; 16962 break; 16963 } 16964 break; 16965 case 0xf8: 16966 GETBYTE (); 16967 switch (op[2] & 0xf0) 16968 { 16969 case 0x00: 16970 case 0x10: 16971 case 0x20: 16972 case 0x30: 16973 case 0x40: 16974 case 0x50: 16975 case 0x60: 16976 case 0x70: 16977 case 0x80: 16978 case 0x90: 16979 case 0xa0: 16980 case 0xb0: 16981 case 0xc0: 16982 case 0xd0: 16983 case 0xe0: 16984 goto op_semantics_139; 16985 break; 16986 case 0xf0: 16987 goto op_semantics_140; 16988 break; 16989 } 16990 break; 16991 case 0xf9: 16992 GETBYTE (); 16993 switch (op[2] & 0xf0) 16994 { 16995 case 0x00: 16996 case 0x10: 16997 case 0x20: 16998 case 0x30: 16999 case 0x40: 17000 case 0x50: 17001 case 0x60: 17002 case 0x70: 17003 case 0x80: 17004 case 0x90: 17005 case 0xa0: 17006 case 0xb0: 17007 case 0xc0: 17008 case 0xd0: 17009 case 0xe0: 17010 goto op_semantics_139; 17011 break; 17012 case 0xf0: 17013 goto op_semantics_140; 17014 break; 17015 } 17016 break; 17017 case 0xfa: 17018 GETBYTE (); 17019 switch (op[2] & 0xf0) 17020 { 17021 case 0x00: 17022 case 0x10: 17023 case 0x20: 17024 case 0x30: 17025 case 0x40: 17026 case 0x50: 17027 case 0x60: 17028 case 0x70: 17029 case 0x80: 17030 case 0x90: 17031 case 0xa0: 17032 case 0xb0: 17033 case 0xc0: 17034 case 0xd0: 17035 case 0xe0: 17036 goto op_semantics_139; 17037 break; 17038 case 0xf0: 17039 goto op_semantics_140; 17040 break; 17041 } 17042 break; 17043 case 0xfb: 17044 GETBYTE (); 17045 switch (op[2] & 0xf0) 17046 { 17047 case 0x00: 17048 case 0x10: 17049 case 0x20: 17050 case 0x30: 17051 case 0x40: 17052 case 0x50: 17053 case 0x60: 17054 case 0x70: 17055 case 0x80: 17056 case 0x90: 17057 case 0xa0: 17058 case 0xb0: 17059 case 0xc0: 17060 case 0xd0: 17061 case 0xe0: 17062 goto op_semantics_139; 17063 break; 17064 case 0xf0: 17065 goto op_semantics_140; 17066 break; 17067 } 17068 break; 17069 case 0xfc: 17070 GETBYTE (); 17071 switch (op[2] & 0xf0) 17072 { 17073 case 0x00: 17074 case 0x10: 17075 case 0x20: 17076 case 0x30: 17077 case 0x40: 17078 case 0x50: 17079 case 0x60: 17080 case 0x70: 17081 case 0x80: 17082 case 0x90: 17083 case 0xa0: 17084 case 0xb0: 17085 case 0xc0: 17086 case 0xd0: 17087 case 0xe0: 17088 goto op_semantics_139; 17089 break; 17090 case 0xf0: 17091 goto op_semantics_140; 17092 break; 17093 } 17094 break; 17095 case 0xfd: 17096 GETBYTE (); 17097 switch (op[2] & 0xf0) 17098 { 17099 case 0x00: 17100 case 0x10: 17101 case 0x20: 17102 case 0x30: 17103 case 0x40: 17104 case 0x50: 17105 case 0x60: 17106 case 0x70: 17107 case 0x80: 17108 case 0x90: 17109 case 0xa0: 17110 case 0xb0: 17111 case 0xc0: 17112 case 0xd0: 17113 case 0xe0: 17114 goto op_semantics_139; 17115 break; 17116 case 0xf0: 17117 goto op_semantics_140; 17118 break; 17119 } 17120 break; 17121 case 0xfe: 17122 GETBYTE (); 17123 switch (op[2] & 0xf0) 17124 { 17125 case 0x00: 17126 case 0x10: 17127 case 0x20: 17128 case 0x30: 17129 case 0x40: 17130 case 0x50: 17131 case 0x60: 17132 case 0x70: 17133 case 0x80: 17134 case 0x90: 17135 case 0xa0: 17136 case 0xb0: 17137 case 0xc0: 17138 case 0xd0: 17139 case 0xe0: 17140 goto op_semantics_139; 17141 break; 17142 case 0xf0: 17143 goto op_semantics_140; 17144 break; 17145 } 17146 break; 17147 case 0xff: 17148 GETBYTE (); 17149 switch (op[2] & 0xf0) 17150 { 17151 case 0x00: 17152 case 0x10: 17153 case 0x20: 17154 case 0x30: 17155 case 0x40: 17156 case 0x50: 17157 case 0x60: 17158 case 0x70: 17159 case 0x80: 17160 case 0x90: 17161 case 0xa0: 17162 case 0xb0: 17163 case 0xc0: 17164 case 0xd0: 17165 case 0xe0: 17166 goto op_semantics_139; 17167 break; 17168 case 0xf0: 17169 goto op_semantics_140; 17170 break; 17171 } 17172 break; 17173 default: UNSUPPORTED(); break; 17174 } 17175 break; 17176 case 0xfe: 17177 GETBYTE (); 17178 switch (op[1] & 0xff) 17179 { 17180 case 0x00: 17181 GETBYTE (); 17182 switch (op[2] & 0x00) 17183 { 17184 case 0x00: 17185 op_semantics_141: 17186 { 17187 /** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */ 17188 #line 363 "rx-decode.opc" 17189 int sz AU = (op[1] >> 4) & 0x03; 17190 #line 363 "rx-decode.opc" 17191 int isrc AU = op[1] & 0x0f; 17192 #line 363 "rx-decode.opc" 17193 int bsrc AU = (op[2] >> 4) & 0x0f; 17194 #line 363 "rx-decode.opc" 17195 int rdst AU = op[2] & 0x0f; 17196 if (trace) 17197 { 17198 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 17199 "/** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */", 17200 op[0], op[1], op[2]); 17201 printf (" sz = 0x%x,", sz); 17202 printf (" isrc = 0x%x,", isrc); 17203 printf (" bsrc = 0x%x,", bsrc); 17204 printf (" rdst = 0x%x\n", rdst); 17205 } 17206 SYNTAX("mov%s %0, [%1, %2]"); 17207 #line 363 "rx-decode.opc" 17208 ID(movbir); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____; 17209 17210 } 17211 break; 17212 } 17213 break; 17214 case 0x01: 17215 GETBYTE (); 17216 switch (op[2] & 0x00) 17217 { 17218 case 0x00: 17219 goto op_semantics_141; 17220 break; 17221 } 17222 break; 17223 case 0x02: 17224 GETBYTE (); 17225 switch (op[2] & 0x00) 17226 { 17227 case 0x00: 17228 goto op_semantics_141; 17229 break; 17230 } 17231 break; 17232 case 0x03: 17233 GETBYTE (); 17234 switch (op[2] & 0x00) 17235 { 17236 case 0x00: 17237 goto op_semantics_141; 17238 break; 17239 } 17240 break; 17241 case 0x04: 17242 GETBYTE (); 17243 switch (op[2] & 0x00) 17244 { 17245 case 0x00: 17246 goto op_semantics_141; 17247 break; 17248 } 17249 break; 17250 case 0x05: 17251 GETBYTE (); 17252 switch (op[2] & 0x00) 17253 { 17254 case 0x00: 17255 goto op_semantics_141; 17256 break; 17257 } 17258 break; 17259 case 0x06: 17260 GETBYTE (); 17261 switch (op[2] & 0x00) 17262 { 17263 case 0x00: 17264 goto op_semantics_141; 17265 break; 17266 } 17267 break; 17268 case 0x07: 17269 GETBYTE (); 17270 switch (op[2] & 0x00) 17271 { 17272 case 0x00: 17273 goto op_semantics_141; 17274 break; 17275 } 17276 break; 17277 case 0x08: 17278 GETBYTE (); 17279 switch (op[2] & 0x00) 17280 { 17281 case 0x00: 17282 goto op_semantics_141; 17283 break; 17284 } 17285 break; 17286 case 0x09: 17287 GETBYTE (); 17288 switch (op[2] & 0x00) 17289 { 17290 case 0x00: 17291 goto op_semantics_141; 17292 break; 17293 } 17294 break; 17295 case 0x0a: 17296 GETBYTE (); 17297 switch (op[2] & 0x00) 17298 { 17299 case 0x00: 17300 goto op_semantics_141; 17301 break; 17302 } 17303 break; 17304 case 0x0b: 17305 GETBYTE (); 17306 switch (op[2] & 0x00) 17307 { 17308 case 0x00: 17309 goto op_semantics_141; 17310 break; 17311 } 17312 break; 17313 case 0x0c: 17314 GETBYTE (); 17315 switch (op[2] & 0x00) 17316 { 17317 case 0x00: 17318 goto op_semantics_141; 17319 break; 17320 } 17321 break; 17322 case 0x0d: 17323 GETBYTE (); 17324 switch (op[2] & 0x00) 17325 { 17326 case 0x00: 17327 goto op_semantics_141; 17328 break; 17329 } 17330 break; 17331 case 0x0e: 17332 GETBYTE (); 17333 switch (op[2] & 0x00) 17334 { 17335 case 0x00: 17336 goto op_semantics_141; 17337 break; 17338 } 17339 break; 17340 case 0x0f: 17341 GETBYTE (); 17342 switch (op[2] & 0x00) 17343 { 17344 case 0x00: 17345 goto op_semantics_141; 17346 break; 17347 } 17348 break; 17349 case 0x10: 17350 GETBYTE (); 17351 switch (op[2] & 0x00) 17352 { 17353 case 0x00: 17354 goto op_semantics_141; 17355 break; 17356 } 17357 break; 17358 case 0x11: 17359 GETBYTE (); 17360 switch (op[2] & 0x00) 17361 { 17362 case 0x00: 17363 goto op_semantics_141; 17364 break; 17365 } 17366 break; 17367 case 0x12: 17368 GETBYTE (); 17369 switch (op[2] & 0x00) 17370 { 17371 case 0x00: 17372 goto op_semantics_141; 17373 break; 17374 } 17375 break; 17376 case 0x13: 17377 GETBYTE (); 17378 switch (op[2] & 0x00) 17379 { 17380 case 0x00: 17381 goto op_semantics_141; 17382 break; 17383 } 17384 break; 17385 case 0x14: 17386 GETBYTE (); 17387 switch (op[2] & 0x00) 17388 { 17389 case 0x00: 17390 goto op_semantics_141; 17391 break; 17392 } 17393 break; 17394 case 0x15: 17395 GETBYTE (); 17396 switch (op[2] & 0x00) 17397 { 17398 case 0x00: 17399 goto op_semantics_141; 17400 break; 17401 } 17402 break; 17403 case 0x16: 17404 GETBYTE (); 17405 switch (op[2] & 0x00) 17406 { 17407 case 0x00: 17408 goto op_semantics_141; 17409 break; 17410 } 17411 break; 17412 case 0x17: 17413 GETBYTE (); 17414 switch (op[2] & 0x00) 17415 { 17416 case 0x00: 17417 goto op_semantics_141; 17418 break; 17419 } 17420 break; 17421 case 0x18: 17422 GETBYTE (); 17423 switch (op[2] & 0x00) 17424 { 17425 case 0x00: 17426 goto op_semantics_141; 17427 break; 17428 } 17429 break; 17430 case 0x19: 17431 GETBYTE (); 17432 switch (op[2] & 0x00) 17433 { 17434 case 0x00: 17435 goto op_semantics_141; 17436 break; 17437 } 17438 break; 17439 case 0x1a: 17440 GETBYTE (); 17441 switch (op[2] & 0x00) 17442 { 17443 case 0x00: 17444 goto op_semantics_141; 17445 break; 17446 } 17447 break; 17448 case 0x1b: 17449 GETBYTE (); 17450 switch (op[2] & 0x00) 17451 { 17452 case 0x00: 17453 goto op_semantics_141; 17454 break; 17455 } 17456 break; 17457 case 0x1c: 17458 GETBYTE (); 17459 switch (op[2] & 0x00) 17460 { 17461 case 0x00: 17462 goto op_semantics_141; 17463 break; 17464 } 17465 break; 17466 case 0x1d: 17467 GETBYTE (); 17468 switch (op[2] & 0x00) 17469 { 17470 case 0x00: 17471 goto op_semantics_141; 17472 break; 17473 } 17474 break; 17475 case 0x1e: 17476 GETBYTE (); 17477 switch (op[2] & 0x00) 17478 { 17479 case 0x00: 17480 goto op_semantics_141; 17481 break; 17482 } 17483 break; 17484 case 0x1f: 17485 GETBYTE (); 17486 switch (op[2] & 0x00) 17487 { 17488 case 0x00: 17489 goto op_semantics_141; 17490 break; 17491 } 17492 break; 17493 case 0x20: 17494 GETBYTE (); 17495 switch (op[2] & 0x00) 17496 { 17497 case 0x00: 17498 goto op_semantics_141; 17499 break; 17500 } 17501 break; 17502 case 0x21: 17503 GETBYTE (); 17504 switch (op[2] & 0x00) 17505 { 17506 case 0x00: 17507 goto op_semantics_141; 17508 break; 17509 } 17510 break; 17511 case 0x22: 17512 GETBYTE (); 17513 switch (op[2] & 0x00) 17514 { 17515 case 0x00: 17516 goto op_semantics_141; 17517 break; 17518 } 17519 break; 17520 case 0x23: 17521 GETBYTE (); 17522 switch (op[2] & 0x00) 17523 { 17524 case 0x00: 17525 goto op_semantics_141; 17526 break; 17527 } 17528 break; 17529 case 0x24: 17530 GETBYTE (); 17531 switch (op[2] & 0x00) 17532 { 17533 case 0x00: 17534 goto op_semantics_141; 17535 break; 17536 } 17537 break; 17538 case 0x25: 17539 GETBYTE (); 17540 switch (op[2] & 0x00) 17541 { 17542 case 0x00: 17543 goto op_semantics_141; 17544 break; 17545 } 17546 break; 17547 case 0x26: 17548 GETBYTE (); 17549 switch (op[2] & 0x00) 17550 { 17551 case 0x00: 17552 goto op_semantics_141; 17553 break; 17554 } 17555 break; 17556 case 0x27: 17557 GETBYTE (); 17558 switch (op[2] & 0x00) 17559 { 17560 case 0x00: 17561 goto op_semantics_141; 17562 break; 17563 } 17564 break; 17565 case 0x28: 17566 GETBYTE (); 17567 switch (op[2] & 0x00) 17568 { 17569 case 0x00: 17570 goto op_semantics_141; 17571 break; 17572 } 17573 break; 17574 case 0x29: 17575 GETBYTE (); 17576 switch (op[2] & 0x00) 17577 { 17578 case 0x00: 17579 goto op_semantics_141; 17580 break; 17581 } 17582 break; 17583 case 0x2a: 17584 GETBYTE (); 17585 switch (op[2] & 0x00) 17586 { 17587 case 0x00: 17588 goto op_semantics_141; 17589 break; 17590 } 17591 break; 17592 case 0x2b: 17593 GETBYTE (); 17594 switch (op[2] & 0x00) 17595 { 17596 case 0x00: 17597 goto op_semantics_141; 17598 break; 17599 } 17600 break; 17601 case 0x2c: 17602 GETBYTE (); 17603 switch (op[2] & 0x00) 17604 { 17605 case 0x00: 17606 goto op_semantics_141; 17607 break; 17608 } 17609 break; 17610 case 0x2d: 17611 GETBYTE (); 17612 switch (op[2] & 0x00) 17613 { 17614 case 0x00: 17615 goto op_semantics_141; 17616 break; 17617 } 17618 break; 17619 case 0x2e: 17620 GETBYTE (); 17621 switch (op[2] & 0x00) 17622 { 17623 case 0x00: 17624 goto op_semantics_141; 17625 break; 17626 } 17627 break; 17628 case 0x2f: 17629 GETBYTE (); 17630 switch (op[2] & 0x00) 17631 { 17632 case 0x00: 17633 goto op_semantics_141; 17634 break; 17635 } 17636 break; 17637 case 0x40: 17638 GETBYTE (); 17639 switch (op[2] & 0x00) 17640 { 17641 case 0x00: 17642 op_semantics_142: 17643 { 17644 /** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */ 17645 #line 360 "rx-decode.opc" 17646 int sz AU = (op[1] >> 4) & 0x03; 17647 #line 360 "rx-decode.opc" 17648 int isrc AU = op[1] & 0x0f; 17649 #line 360 "rx-decode.opc" 17650 int bsrc AU = (op[2] >> 4) & 0x0f; 17651 #line 360 "rx-decode.opc" 17652 int rdst AU = op[2] & 0x0f; 17653 if (trace) 17654 { 17655 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 17656 "/** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */", 17657 op[0], op[1], op[2]); 17658 printf (" sz = 0x%x,", sz); 17659 printf (" isrc = 0x%x,", isrc); 17660 printf (" bsrc = 0x%x,", bsrc); 17661 printf (" rdst = 0x%x\n", rdst); 17662 } 17663 SYNTAX("mov%s [%1, %2], %0"); 17664 #line 360 "rx-decode.opc" 17665 ID(movbi); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____; 17666 17667 } 17668 break; 17669 } 17670 break; 17671 case 0x41: 17672 GETBYTE (); 17673 switch (op[2] & 0x00) 17674 { 17675 case 0x00: 17676 goto op_semantics_142; 17677 break; 17678 } 17679 break; 17680 case 0x42: 17681 GETBYTE (); 17682 switch (op[2] & 0x00) 17683 { 17684 case 0x00: 17685 goto op_semantics_142; 17686 break; 17687 } 17688 break; 17689 case 0x43: 17690 GETBYTE (); 17691 switch (op[2] & 0x00) 17692 { 17693 case 0x00: 17694 goto op_semantics_142; 17695 break; 17696 } 17697 break; 17698 case 0x44: 17699 GETBYTE (); 17700 switch (op[2] & 0x00) 17701 { 17702 case 0x00: 17703 goto op_semantics_142; 17704 break; 17705 } 17706 break; 17707 case 0x45: 17708 GETBYTE (); 17709 switch (op[2] & 0x00) 17710 { 17711 case 0x00: 17712 goto op_semantics_142; 17713 break; 17714 } 17715 break; 17716 case 0x46: 17717 GETBYTE (); 17718 switch (op[2] & 0x00) 17719 { 17720 case 0x00: 17721 goto op_semantics_142; 17722 break; 17723 } 17724 break; 17725 case 0x47: 17726 GETBYTE (); 17727 switch (op[2] & 0x00) 17728 { 17729 case 0x00: 17730 goto op_semantics_142; 17731 break; 17732 } 17733 break; 17734 case 0x48: 17735 GETBYTE (); 17736 switch (op[2] & 0x00) 17737 { 17738 case 0x00: 17739 goto op_semantics_142; 17740 break; 17741 } 17742 break; 17743 case 0x49: 17744 GETBYTE (); 17745 switch (op[2] & 0x00) 17746 { 17747 case 0x00: 17748 goto op_semantics_142; 17749 break; 17750 } 17751 break; 17752 case 0x4a: 17753 GETBYTE (); 17754 switch (op[2] & 0x00) 17755 { 17756 case 0x00: 17757 goto op_semantics_142; 17758 break; 17759 } 17760 break; 17761 case 0x4b: 17762 GETBYTE (); 17763 switch (op[2] & 0x00) 17764 { 17765 case 0x00: 17766 goto op_semantics_142; 17767 break; 17768 } 17769 break; 17770 case 0x4c: 17771 GETBYTE (); 17772 switch (op[2] & 0x00) 17773 { 17774 case 0x00: 17775 goto op_semantics_142; 17776 break; 17777 } 17778 break; 17779 case 0x4d: 17780 GETBYTE (); 17781 switch (op[2] & 0x00) 17782 { 17783 case 0x00: 17784 goto op_semantics_142; 17785 break; 17786 } 17787 break; 17788 case 0x4e: 17789 GETBYTE (); 17790 switch (op[2] & 0x00) 17791 { 17792 case 0x00: 17793 goto op_semantics_142; 17794 break; 17795 } 17796 break; 17797 case 0x4f: 17798 GETBYTE (); 17799 switch (op[2] & 0x00) 17800 { 17801 case 0x00: 17802 goto op_semantics_142; 17803 break; 17804 } 17805 break; 17806 case 0x50: 17807 GETBYTE (); 17808 switch (op[2] & 0x00) 17809 { 17810 case 0x00: 17811 goto op_semantics_142; 17812 break; 17813 } 17814 break; 17815 case 0x51: 17816 GETBYTE (); 17817 switch (op[2] & 0x00) 17818 { 17819 case 0x00: 17820 goto op_semantics_142; 17821 break; 17822 } 17823 break; 17824 case 0x52: 17825 GETBYTE (); 17826 switch (op[2] & 0x00) 17827 { 17828 case 0x00: 17829 goto op_semantics_142; 17830 break; 17831 } 17832 break; 17833 case 0x53: 17834 GETBYTE (); 17835 switch (op[2] & 0x00) 17836 { 17837 case 0x00: 17838 goto op_semantics_142; 17839 break; 17840 } 17841 break; 17842 case 0x54: 17843 GETBYTE (); 17844 switch (op[2] & 0x00) 17845 { 17846 case 0x00: 17847 goto op_semantics_142; 17848 break; 17849 } 17850 break; 17851 case 0x55: 17852 GETBYTE (); 17853 switch (op[2] & 0x00) 17854 { 17855 case 0x00: 17856 goto op_semantics_142; 17857 break; 17858 } 17859 break; 17860 case 0x56: 17861 GETBYTE (); 17862 switch (op[2] & 0x00) 17863 { 17864 case 0x00: 17865 goto op_semantics_142; 17866 break; 17867 } 17868 break; 17869 case 0x57: 17870 GETBYTE (); 17871 switch (op[2] & 0x00) 17872 { 17873 case 0x00: 17874 goto op_semantics_142; 17875 break; 17876 } 17877 break; 17878 case 0x58: 17879 GETBYTE (); 17880 switch (op[2] & 0x00) 17881 { 17882 case 0x00: 17883 goto op_semantics_142; 17884 break; 17885 } 17886 break; 17887 case 0x59: 17888 GETBYTE (); 17889 switch (op[2] & 0x00) 17890 { 17891 case 0x00: 17892 goto op_semantics_142; 17893 break; 17894 } 17895 break; 17896 case 0x5a: 17897 GETBYTE (); 17898 switch (op[2] & 0x00) 17899 { 17900 case 0x00: 17901 goto op_semantics_142; 17902 break; 17903 } 17904 break; 17905 case 0x5b: 17906 GETBYTE (); 17907 switch (op[2] & 0x00) 17908 { 17909 case 0x00: 17910 goto op_semantics_142; 17911 break; 17912 } 17913 break; 17914 case 0x5c: 17915 GETBYTE (); 17916 switch (op[2] & 0x00) 17917 { 17918 case 0x00: 17919 goto op_semantics_142; 17920 break; 17921 } 17922 break; 17923 case 0x5d: 17924 GETBYTE (); 17925 switch (op[2] & 0x00) 17926 { 17927 case 0x00: 17928 goto op_semantics_142; 17929 break; 17930 } 17931 break; 17932 case 0x5e: 17933 GETBYTE (); 17934 switch (op[2] & 0x00) 17935 { 17936 case 0x00: 17937 goto op_semantics_142; 17938 break; 17939 } 17940 break; 17941 case 0x5f: 17942 GETBYTE (); 17943 switch (op[2] & 0x00) 17944 { 17945 case 0x00: 17946 goto op_semantics_142; 17947 break; 17948 } 17949 break; 17950 case 0x60: 17951 GETBYTE (); 17952 switch (op[2] & 0x00) 17953 { 17954 case 0x00: 17955 goto op_semantics_142; 17956 break; 17957 } 17958 break; 17959 case 0x61: 17960 GETBYTE (); 17961 switch (op[2] & 0x00) 17962 { 17963 case 0x00: 17964 goto op_semantics_142; 17965 break; 17966 } 17967 break; 17968 case 0x62: 17969 GETBYTE (); 17970 switch (op[2] & 0x00) 17971 { 17972 case 0x00: 17973 goto op_semantics_142; 17974 break; 17975 } 17976 break; 17977 case 0x63: 17978 GETBYTE (); 17979 switch (op[2] & 0x00) 17980 { 17981 case 0x00: 17982 goto op_semantics_142; 17983 break; 17984 } 17985 break; 17986 case 0x64: 17987 GETBYTE (); 17988 switch (op[2] & 0x00) 17989 { 17990 case 0x00: 17991 goto op_semantics_142; 17992 break; 17993 } 17994 break; 17995 case 0x65: 17996 GETBYTE (); 17997 switch (op[2] & 0x00) 17998 { 17999 case 0x00: 18000 goto op_semantics_142; 18001 break; 18002 } 18003 break; 18004 case 0x66: 18005 GETBYTE (); 18006 switch (op[2] & 0x00) 18007 { 18008 case 0x00: 18009 goto op_semantics_142; 18010 break; 18011 } 18012 break; 18013 case 0x67: 18014 GETBYTE (); 18015 switch (op[2] & 0x00) 18016 { 18017 case 0x00: 18018 goto op_semantics_142; 18019 break; 18020 } 18021 break; 18022 case 0x68: 18023 GETBYTE (); 18024 switch (op[2] & 0x00) 18025 { 18026 case 0x00: 18027 goto op_semantics_142; 18028 break; 18029 } 18030 break; 18031 case 0x69: 18032 GETBYTE (); 18033 switch (op[2] & 0x00) 18034 { 18035 case 0x00: 18036 goto op_semantics_142; 18037 break; 18038 } 18039 break; 18040 case 0x6a: 18041 GETBYTE (); 18042 switch (op[2] & 0x00) 18043 { 18044 case 0x00: 18045 goto op_semantics_142; 18046 break; 18047 } 18048 break; 18049 case 0x6b: 18050 GETBYTE (); 18051 switch (op[2] & 0x00) 18052 { 18053 case 0x00: 18054 goto op_semantics_142; 18055 break; 18056 } 18057 break; 18058 case 0x6c: 18059 GETBYTE (); 18060 switch (op[2] & 0x00) 18061 { 18062 case 0x00: 18063 goto op_semantics_142; 18064 break; 18065 } 18066 break; 18067 case 0x6d: 18068 GETBYTE (); 18069 switch (op[2] & 0x00) 18070 { 18071 case 0x00: 18072 goto op_semantics_142; 18073 break; 18074 } 18075 break; 18076 case 0x6e: 18077 GETBYTE (); 18078 switch (op[2] & 0x00) 18079 { 18080 case 0x00: 18081 goto op_semantics_142; 18082 break; 18083 } 18084 break; 18085 case 0x6f: 18086 GETBYTE (); 18087 switch (op[2] & 0x00) 18088 { 18089 case 0x00: 18090 goto op_semantics_142; 18091 break; 18092 } 18093 break; 18094 case 0xc0: 18095 GETBYTE (); 18096 switch (op[2] & 0x00) 18097 { 18098 case 0x00: 18099 op_semantics_143: 18100 { 18101 /** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */ 18102 #line 366 "rx-decode.opc" 18103 int sz AU = (op[1] >> 4) & 0x03; 18104 #line 366 "rx-decode.opc" 18105 int isrc AU = op[1] & 0x0f; 18106 #line 366 "rx-decode.opc" 18107 int bsrc AU = (op[2] >> 4) & 0x0f; 18108 #line 366 "rx-decode.opc" 18109 int rdst AU = op[2] & 0x0f; 18110 if (trace) 18111 { 18112 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 18113 "/** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */", 18114 op[0], op[1], op[2]); 18115 printf (" sz = 0x%x,", sz); 18116 printf (" isrc = 0x%x,", isrc); 18117 printf (" bsrc = 0x%x,", bsrc); 18118 printf (" rdst = 0x%x\n", rdst); 18119 } 18120 SYNTAX("movu%s [%1, %2], %0"); 18121 #line 366 "rx-decode.opc" 18122 ID(movbi); uBW(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____; 18123 18124 } 18125 break; 18126 } 18127 break; 18128 case 0xc1: 18129 GETBYTE (); 18130 switch (op[2] & 0x00) 18131 { 18132 case 0x00: 18133 goto op_semantics_143; 18134 break; 18135 } 18136 break; 18137 case 0xc2: 18138 GETBYTE (); 18139 switch (op[2] & 0x00) 18140 { 18141 case 0x00: 18142 goto op_semantics_143; 18143 break; 18144 } 18145 break; 18146 case 0xc3: 18147 GETBYTE (); 18148 switch (op[2] & 0x00) 18149 { 18150 case 0x00: 18151 goto op_semantics_143; 18152 break; 18153 } 18154 break; 18155 case 0xc4: 18156 GETBYTE (); 18157 switch (op[2] & 0x00) 18158 { 18159 case 0x00: 18160 goto op_semantics_143; 18161 break; 18162 } 18163 break; 18164 case 0xc5: 18165 GETBYTE (); 18166 switch (op[2] & 0x00) 18167 { 18168 case 0x00: 18169 goto op_semantics_143; 18170 break; 18171 } 18172 break; 18173 case 0xc6: 18174 GETBYTE (); 18175 switch (op[2] & 0x00) 18176 { 18177 case 0x00: 18178 goto op_semantics_143; 18179 break; 18180 } 18181 break; 18182 case 0xc7: 18183 GETBYTE (); 18184 switch (op[2] & 0x00) 18185 { 18186 case 0x00: 18187 goto op_semantics_143; 18188 break; 18189 } 18190 break; 18191 case 0xc8: 18192 GETBYTE (); 18193 switch (op[2] & 0x00) 18194 { 18195 case 0x00: 18196 goto op_semantics_143; 18197 break; 18198 } 18199 break; 18200 case 0xc9: 18201 GETBYTE (); 18202 switch (op[2] & 0x00) 18203 { 18204 case 0x00: 18205 goto op_semantics_143; 18206 break; 18207 } 18208 break; 18209 case 0xca: 18210 GETBYTE (); 18211 switch (op[2] & 0x00) 18212 { 18213 case 0x00: 18214 goto op_semantics_143; 18215 break; 18216 } 18217 break; 18218 case 0xcb: 18219 GETBYTE (); 18220 switch (op[2] & 0x00) 18221 { 18222 case 0x00: 18223 goto op_semantics_143; 18224 break; 18225 } 18226 break; 18227 case 0xcc: 18228 GETBYTE (); 18229 switch (op[2] & 0x00) 18230 { 18231 case 0x00: 18232 goto op_semantics_143; 18233 break; 18234 } 18235 break; 18236 case 0xcd: 18237 GETBYTE (); 18238 switch (op[2] & 0x00) 18239 { 18240 case 0x00: 18241 goto op_semantics_143; 18242 break; 18243 } 18244 break; 18245 case 0xce: 18246 GETBYTE (); 18247 switch (op[2] & 0x00) 18248 { 18249 case 0x00: 18250 goto op_semantics_143; 18251 break; 18252 } 18253 break; 18254 case 0xcf: 18255 GETBYTE (); 18256 switch (op[2] & 0x00) 18257 { 18258 case 0x00: 18259 goto op_semantics_143; 18260 break; 18261 } 18262 break; 18263 case 0xd0: 18264 GETBYTE (); 18265 switch (op[2] & 0x00) 18266 { 18267 case 0x00: 18268 goto op_semantics_143; 18269 break; 18270 } 18271 break; 18272 case 0xd1: 18273 GETBYTE (); 18274 switch (op[2] & 0x00) 18275 { 18276 case 0x00: 18277 goto op_semantics_143; 18278 break; 18279 } 18280 break; 18281 case 0xd2: 18282 GETBYTE (); 18283 switch (op[2] & 0x00) 18284 { 18285 case 0x00: 18286 goto op_semantics_143; 18287 break; 18288 } 18289 break; 18290 case 0xd3: 18291 GETBYTE (); 18292 switch (op[2] & 0x00) 18293 { 18294 case 0x00: 18295 goto op_semantics_143; 18296 break; 18297 } 18298 break; 18299 case 0xd4: 18300 GETBYTE (); 18301 switch (op[2] & 0x00) 18302 { 18303 case 0x00: 18304 goto op_semantics_143; 18305 break; 18306 } 18307 break; 18308 case 0xd5: 18309 GETBYTE (); 18310 switch (op[2] & 0x00) 18311 { 18312 case 0x00: 18313 goto op_semantics_143; 18314 break; 18315 } 18316 break; 18317 case 0xd6: 18318 GETBYTE (); 18319 switch (op[2] & 0x00) 18320 { 18321 case 0x00: 18322 goto op_semantics_143; 18323 break; 18324 } 18325 break; 18326 case 0xd7: 18327 GETBYTE (); 18328 switch (op[2] & 0x00) 18329 { 18330 case 0x00: 18331 goto op_semantics_143; 18332 break; 18333 } 18334 break; 18335 case 0xd8: 18336 GETBYTE (); 18337 switch (op[2] & 0x00) 18338 { 18339 case 0x00: 18340 goto op_semantics_143; 18341 break; 18342 } 18343 break; 18344 case 0xd9: 18345 GETBYTE (); 18346 switch (op[2] & 0x00) 18347 { 18348 case 0x00: 18349 goto op_semantics_143; 18350 break; 18351 } 18352 break; 18353 case 0xda: 18354 GETBYTE (); 18355 switch (op[2] & 0x00) 18356 { 18357 case 0x00: 18358 goto op_semantics_143; 18359 break; 18360 } 18361 break; 18362 case 0xdb: 18363 GETBYTE (); 18364 switch (op[2] & 0x00) 18365 { 18366 case 0x00: 18367 goto op_semantics_143; 18368 break; 18369 } 18370 break; 18371 case 0xdc: 18372 GETBYTE (); 18373 switch (op[2] & 0x00) 18374 { 18375 case 0x00: 18376 goto op_semantics_143; 18377 break; 18378 } 18379 break; 18380 case 0xdd: 18381 GETBYTE (); 18382 switch (op[2] & 0x00) 18383 { 18384 case 0x00: 18385 goto op_semantics_143; 18386 break; 18387 } 18388 break; 18389 case 0xde: 18390 GETBYTE (); 18391 switch (op[2] & 0x00) 18392 { 18393 case 0x00: 18394 goto op_semantics_143; 18395 break; 18396 } 18397 break; 18398 case 0xdf: 18399 GETBYTE (); 18400 switch (op[2] & 0x00) 18401 { 18402 case 0x00: 18403 goto op_semantics_143; 18404 break; 18405 } 18406 break; 18407 case 0xe0: 18408 GETBYTE (); 18409 switch (op[2] & 0x00) 18410 { 18411 case 0x00: 18412 goto op_semantics_143; 18413 break; 18414 } 18415 break; 18416 case 0xe1: 18417 GETBYTE (); 18418 switch (op[2] & 0x00) 18419 { 18420 case 0x00: 18421 goto op_semantics_143; 18422 break; 18423 } 18424 break; 18425 case 0xe2: 18426 GETBYTE (); 18427 switch (op[2] & 0x00) 18428 { 18429 case 0x00: 18430 goto op_semantics_143; 18431 break; 18432 } 18433 break; 18434 case 0xe3: 18435 GETBYTE (); 18436 switch (op[2] & 0x00) 18437 { 18438 case 0x00: 18439 goto op_semantics_143; 18440 break; 18441 } 18442 break; 18443 case 0xe4: 18444 GETBYTE (); 18445 switch (op[2] & 0x00) 18446 { 18447 case 0x00: 18448 goto op_semantics_143; 18449 break; 18450 } 18451 break; 18452 case 0xe5: 18453 GETBYTE (); 18454 switch (op[2] & 0x00) 18455 { 18456 case 0x00: 18457 goto op_semantics_143; 18458 break; 18459 } 18460 break; 18461 case 0xe6: 18462 GETBYTE (); 18463 switch (op[2] & 0x00) 18464 { 18465 case 0x00: 18466 goto op_semantics_143; 18467 break; 18468 } 18469 break; 18470 case 0xe7: 18471 GETBYTE (); 18472 switch (op[2] & 0x00) 18473 { 18474 case 0x00: 18475 goto op_semantics_143; 18476 break; 18477 } 18478 break; 18479 case 0xe8: 18480 GETBYTE (); 18481 switch (op[2] & 0x00) 18482 { 18483 case 0x00: 18484 goto op_semantics_143; 18485 break; 18486 } 18487 break; 18488 case 0xe9: 18489 GETBYTE (); 18490 switch (op[2] & 0x00) 18491 { 18492 case 0x00: 18493 goto op_semantics_143; 18494 break; 18495 } 18496 break; 18497 case 0xea: 18498 GETBYTE (); 18499 switch (op[2] & 0x00) 18500 { 18501 case 0x00: 18502 goto op_semantics_143; 18503 break; 18504 } 18505 break; 18506 case 0xeb: 18507 GETBYTE (); 18508 switch (op[2] & 0x00) 18509 { 18510 case 0x00: 18511 goto op_semantics_143; 18512 break; 18513 } 18514 break; 18515 case 0xec: 18516 GETBYTE (); 18517 switch (op[2] & 0x00) 18518 { 18519 case 0x00: 18520 goto op_semantics_143; 18521 break; 18522 } 18523 break; 18524 case 0xed: 18525 GETBYTE (); 18526 switch (op[2] & 0x00) 18527 { 18528 case 0x00: 18529 goto op_semantics_143; 18530 break; 18531 } 18532 break; 18533 case 0xee: 18534 GETBYTE (); 18535 switch (op[2] & 0x00) 18536 { 18537 case 0x00: 18538 goto op_semantics_143; 18539 break; 18540 } 18541 break; 18542 case 0xef: 18543 GETBYTE (); 18544 switch (op[2] & 0x00) 18545 { 18546 case 0x00: 18547 goto op_semantics_143; 18548 break; 18549 } 18550 break; 18551 default: UNSUPPORTED(); break; 18552 } 18553 break; 18554 case 0xff: 18555 GETBYTE (); 18556 switch (op[1] & 0xff) 18557 { 18558 case 0x00: 18559 GETBYTE (); 18560 switch (op[2] & 0x00) 18561 { 18562 case 0x00: 18563 op_semantics_144: 18564 { 18565 /** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */ 18566 #line 570 "rx-decode.opc" 18567 int rdst AU = op[1] & 0x0f; 18568 #line 570 "rx-decode.opc" 18569 int srca AU = (op[2] >> 4) & 0x0f; 18570 #line 570 "rx-decode.opc" 18571 int srcb AU = op[2] & 0x0f; 18572 if (trace) 18573 { 18574 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 18575 "/** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */", 18576 op[0], op[1], op[2]); 18577 printf (" rdst = 0x%x,", rdst); 18578 printf (" srca = 0x%x,", srca); 18579 printf (" srcb = 0x%x\n", srcb); 18580 } 18581 SYNTAX("sub %2, %1, %0"); 18582 #line 570 "rx-decode.opc" 18583 ID(sub); DR(rdst); SR(srcb); S2R(srca); F_OSZC; 18584 18585 /*----------------------------------------------------------------------*/ 18586 /* SBB */ 18587 18588 } 18589 break; 18590 } 18591 break; 18592 case 0x01: 18593 GETBYTE (); 18594 switch (op[2] & 0x00) 18595 { 18596 case 0x00: 18597 goto op_semantics_144; 18598 break; 18599 } 18600 break; 18601 case 0x02: 18602 GETBYTE (); 18603 switch (op[2] & 0x00) 18604 { 18605 case 0x00: 18606 goto op_semantics_144; 18607 break; 18608 } 18609 break; 18610 case 0x03: 18611 GETBYTE (); 18612 switch (op[2] & 0x00) 18613 { 18614 case 0x00: 18615 goto op_semantics_144; 18616 break; 18617 } 18618 break; 18619 case 0x04: 18620 GETBYTE (); 18621 switch (op[2] & 0x00) 18622 { 18623 case 0x00: 18624 goto op_semantics_144; 18625 break; 18626 } 18627 break; 18628 case 0x05: 18629 GETBYTE (); 18630 switch (op[2] & 0x00) 18631 { 18632 case 0x00: 18633 goto op_semantics_144; 18634 break; 18635 } 18636 break; 18637 case 0x06: 18638 GETBYTE (); 18639 switch (op[2] & 0x00) 18640 { 18641 case 0x00: 18642 goto op_semantics_144; 18643 break; 18644 } 18645 break; 18646 case 0x07: 18647 GETBYTE (); 18648 switch (op[2] & 0x00) 18649 { 18650 case 0x00: 18651 goto op_semantics_144; 18652 break; 18653 } 18654 break; 18655 case 0x08: 18656 GETBYTE (); 18657 switch (op[2] & 0x00) 18658 { 18659 case 0x00: 18660 goto op_semantics_144; 18661 break; 18662 } 18663 break; 18664 case 0x09: 18665 GETBYTE (); 18666 switch (op[2] & 0x00) 18667 { 18668 case 0x00: 18669 goto op_semantics_144; 18670 break; 18671 } 18672 break; 18673 case 0x0a: 18674 GETBYTE (); 18675 switch (op[2] & 0x00) 18676 { 18677 case 0x00: 18678 goto op_semantics_144; 18679 break; 18680 } 18681 break; 18682 case 0x0b: 18683 GETBYTE (); 18684 switch (op[2] & 0x00) 18685 { 18686 case 0x00: 18687 goto op_semantics_144; 18688 break; 18689 } 18690 break; 18691 case 0x0c: 18692 GETBYTE (); 18693 switch (op[2] & 0x00) 18694 { 18695 case 0x00: 18696 goto op_semantics_144; 18697 break; 18698 } 18699 break; 18700 case 0x0d: 18701 GETBYTE (); 18702 switch (op[2] & 0x00) 18703 { 18704 case 0x00: 18705 goto op_semantics_144; 18706 break; 18707 } 18708 break; 18709 case 0x0e: 18710 GETBYTE (); 18711 switch (op[2] & 0x00) 18712 { 18713 case 0x00: 18714 goto op_semantics_144; 18715 break; 18716 } 18717 break; 18718 case 0x0f: 18719 GETBYTE (); 18720 switch (op[2] & 0x00) 18721 { 18722 case 0x00: 18723 goto op_semantics_144; 18724 break; 18725 } 18726 break; 18727 case 0x20: 18728 GETBYTE (); 18729 switch (op[2] & 0x00) 18730 { 18731 case 0x00: 18732 op_semantics_145: 18733 { 18734 /** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */ 18735 #line 537 "rx-decode.opc" 18736 int rdst AU = op[1] & 0x0f; 18737 #line 537 "rx-decode.opc" 18738 int srca AU = (op[2] >> 4) & 0x0f; 18739 #line 537 "rx-decode.opc" 18740 int srcb AU = op[2] & 0x0f; 18741 if (trace) 18742 { 18743 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 18744 "/** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */", 18745 op[0], op[1], op[2]); 18746 printf (" rdst = 0x%x,", rdst); 18747 printf (" srca = 0x%x,", srca); 18748 printf (" srcb = 0x%x\n", srcb); 18749 } 18750 SYNTAX("add %2, %1, %0"); 18751 #line 537 "rx-decode.opc" 18752 ID(add); DR(rdst); SR(srcb); S2R(srca); F_OSZC; 18753 18754 /*----------------------------------------------------------------------*/ 18755 /* CMP */ 18756 18757 } 18758 break; 18759 } 18760 break; 18761 case 0x21: 18762 GETBYTE (); 18763 switch (op[2] & 0x00) 18764 { 18765 case 0x00: 18766 goto op_semantics_145; 18767 break; 18768 } 18769 break; 18770 case 0x22: 18771 GETBYTE (); 18772 switch (op[2] & 0x00) 18773 { 18774 case 0x00: 18775 goto op_semantics_145; 18776 break; 18777 } 18778 break; 18779 case 0x23: 18780 GETBYTE (); 18781 switch (op[2] & 0x00) 18782 { 18783 case 0x00: 18784 goto op_semantics_145; 18785 break; 18786 } 18787 break; 18788 case 0x24: 18789 GETBYTE (); 18790 switch (op[2] & 0x00) 18791 { 18792 case 0x00: 18793 goto op_semantics_145; 18794 break; 18795 } 18796 break; 18797 case 0x25: 18798 GETBYTE (); 18799 switch (op[2] & 0x00) 18800 { 18801 case 0x00: 18802 goto op_semantics_145; 18803 break; 18804 } 18805 break; 18806 case 0x26: 18807 GETBYTE (); 18808 switch (op[2] & 0x00) 18809 { 18810 case 0x00: 18811 goto op_semantics_145; 18812 break; 18813 } 18814 break; 18815 case 0x27: 18816 GETBYTE (); 18817 switch (op[2] & 0x00) 18818 { 18819 case 0x00: 18820 goto op_semantics_145; 18821 break; 18822 } 18823 break; 18824 case 0x28: 18825 GETBYTE (); 18826 switch (op[2] & 0x00) 18827 { 18828 case 0x00: 18829 goto op_semantics_145; 18830 break; 18831 } 18832 break; 18833 case 0x29: 18834 GETBYTE (); 18835 switch (op[2] & 0x00) 18836 { 18837 case 0x00: 18838 goto op_semantics_145; 18839 break; 18840 } 18841 break; 18842 case 0x2a: 18843 GETBYTE (); 18844 switch (op[2] & 0x00) 18845 { 18846 case 0x00: 18847 goto op_semantics_145; 18848 break; 18849 } 18850 break; 18851 case 0x2b: 18852 GETBYTE (); 18853 switch (op[2] & 0x00) 18854 { 18855 case 0x00: 18856 goto op_semantics_145; 18857 break; 18858 } 18859 break; 18860 case 0x2c: 18861 GETBYTE (); 18862 switch (op[2] & 0x00) 18863 { 18864 case 0x00: 18865 goto op_semantics_145; 18866 break; 18867 } 18868 break; 18869 case 0x2d: 18870 GETBYTE (); 18871 switch (op[2] & 0x00) 18872 { 18873 case 0x00: 18874 goto op_semantics_145; 18875 break; 18876 } 18877 break; 18878 case 0x2e: 18879 GETBYTE (); 18880 switch (op[2] & 0x00) 18881 { 18882 case 0x00: 18883 goto op_semantics_145; 18884 break; 18885 } 18886 break; 18887 case 0x2f: 18888 GETBYTE (); 18889 switch (op[2] & 0x00) 18890 { 18891 case 0x00: 18892 goto op_semantics_145; 18893 break; 18894 } 18895 break; 18896 case 0x30: 18897 GETBYTE (); 18898 switch (op[2] & 0x00) 18899 { 18900 case 0x00: 18901 op_semantics_146: 18902 { 18903 /** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */ 18904 #line 677 "rx-decode.opc" 18905 int rdst AU = op[1] & 0x0f; 18906 #line 677 "rx-decode.opc" 18907 int srca AU = (op[2] >> 4) & 0x0f; 18908 #line 677 "rx-decode.opc" 18909 int srcb AU = op[2] & 0x0f; 18910 if (trace) 18911 { 18912 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 18913 "/** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */", 18914 op[0], op[1], op[2]); 18915 printf (" rdst = 0x%x,", rdst); 18916 printf (" srca = 0x%x,", srca); 18917 printf (" srcb = 0x%x\n", srcb); 18918 } 18919 SYNTAX("mul %2, %1, %0"); 18920 #line 677 "rx-decode.opc" 18921 ID(mul); DR(rdst); SR(srcb); S2R(srca); F_____; 18922 18923 /*----------------------------------------------------------------------*/ 18924 /* EMUL */ 18925 18926 } 18927 break; 18928 } 18929 break; 18930 case 0x31: 18931 GETBYTE (); 18932 switch (op[2] & 0x00) 18933 { 18934 case 0x00: 18935 goto op_semantics_146; 18936 break; 18937 } 18938 break; 18939 case 0x32: 18940 GETBYTE (); 18941 switch (op[2] & 0x00) 18942 { 18943 case 0x00: 18944 goto op_semantics_146; 18945 break; 18946 } 18947 break; 18948 case 0x33: 18949 GETBYTE (); 18950 switch (op[2] & 0x00) 18951 { 18952 case 0x00: 18953 goto op_semantics_146; 18954 break; 18955 } 18956 break; 18957 case 0x34: 18958 GETBYTE (); 18959 switch (op[2] & 0x00) 18960 { 18961 case 0x00: 18962 goto op_semantics_146; 18963 break; 18964 } 18965 break; 18966 case 0x35: 18967 GETBYTE (); 18968 switch (op[2] & 0x00) 18969 { 18970 case 0x00: 18971 goto op_semantics_146; 18972 break; 18973 } 18974 break; 18975 case 0x36: 18976 GETBYTE (); 18977 switch (op[2] & 0x00) 18978 { 18979 case 0x00: 18980 goto op_semantics_146; 18981 break; 18982 } 18983 break; 18984 case 0x37: 18985 GETBYTE (); 18986 switch (op[2] & 0x00) 18987 { 18988 case 0x00: 18989 goto op_semantics_146; 18990 break; 18991 } 18992 break; 18993 case 0x38: 18994 GETBYTE (); 18995 switch (op[2] & 0x00) 18996 { 18997 case 0x00: 18998 goto op_semantics_146; 18999 break; 19000 } 19001 break; 19002 case 0x39: 19003 GETBYTE (); 19004 switch (op[2] & 0x00) 19005 { 19006 case 0x00: 19007 goto op_semantics_146; 19008 break; 19009 } 19010 break; 19011 case 0x3a: 19012 GETBYTE (); 19013 switch (op[2] & 0x00) 19014 { 19015 case 0x00: 19016 goto op_semantics_146; 19017 break; 19018 } 19019 break; 19020 case 0x3b: 19021 GETBYTE (); 19022 switch (op[2] & 0x00) 19023 { 19024 case 0x00: 19025 goto op_semantics_146; 19026 break; 19027 } 19028 break; 19029 case 0x3c: 19030 GETBYTE (); 19031 switch (op[2] & 0x00) 19032 { 19033 case 0x00: 19034 goto op_semantics_146; 19035 break; 19036 } 19037 break; 19038 case 0x3d: 19039 GETBYTE (); 19040 switch (op[2] & 0x00) 19041 { 19042 case 0x00: 19043 goto op_semantics_146; 19044 break; 19045 } 19046 break; 19047 case 0x3e: 19048 GETBYTE (); 19049 switch (op[2] & 0x00) 19050 { 19051 case 0x00: 19052 goto op_semantics_146; 19053 break; 19054 } 19055 break; 19056 case 0x3f: 19057 GETBYTE (); 19058 switch (op[2] & 0x00) 19059 { 19060 case 0x00: 19061 goto op_semantics_146; 19062 break; 19063 } 19064 break; 19065 case 0x40: 19066 GETBYTE (); 19067 switch (op[2] & 0x00) 19068 { 19069 case 0x00: 19070 op_semantics_147: 19071 { 19072 /** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */ 19073 #line 447 "rx-decode.opc" 19074 int rdst AU = op[1] & 0x0f; 19075 #line 447 "rx-decode.opc" 19076 int srca AU = (op[2] >> 4) & 0x0f; 19077 #line 447 "rx-decode.opc" 19078 int srcb AU = op[2] & 0x0f; 19079 if (trace) 19080 { 19081 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 19082 "/** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */", 19083 op[0], op[1], op[2]); 19084 printf (" rdst = 0x%x,", rdst); 19085 printf (" srca = 0x%x,", srca); 19086 printf (" srcb = 0x%x\n", srcb); 19087 } 19088 SYNTAX("and %2, %1, %0"); 19089 #line 447 "rx-decode.opc" 19090 ID(and); DR(rdst); SR(srcb); S2R(srca); F__SZ_; 19091 19092 /*----------------------------------------------------------------------*/ 19093 /* OR */ 19094 19095 } 19096 break; 19097 } 19098 break; 19099 case 0x41: 19100 GETBYTE (); 19101 switch (op[2] & 0x00) 19102 { 19103 case 0x00: 19104 goto op_semantics_147; 19105 break; 19106 } 19107 break; 19108 case 0x42: 19109 GETBYTE (); 19110 switch (op[2] & 0x00) 19111 { 19112 case 0x00: 19113 goto op_semantics_147; 19114 break; 19115 } 19116 break; 19117 case 0x43: 19118 GETBYTE (); 19119 switch (op[2] & 0x00) 19120 { 19121 case 0x00: 19122 goto op_semantics_147; 19123 break; 19124 } 19125 break; 19126 case 0x44: 19127 GETBYTE (); 19128 switch (op[2] & 0x00) 19129 { 19130 case 0x00: 19131 goto op_semantics_147; 19132 break; 19133 } 19134 break; 19135 case 0x45: 19136 GETBYTE (); 19137 switch (op[2] & 0x00) 19138 { 19139 case 0x00: 19140 goto op_semantics_147; 19141 break; 19142 } 19143 break; 19144 case 0x46: 19145 GETBYTE (); 19146 switch (op[2] & 0x00) 19147 { 19148 case 0x00: 19149 goto op_semantics_147; 19150 break; 19151 } 19152 break; 19153 case 0x47: 19154 GETBYTE (); 19155 switch (op[2] & 0x00) 19156 { 19157 case 0x00: 19158 goto op_semantics_147; 19159 break; 19160 } 19161 break; 19162 case 0x48: 19163 GETBYTE (); 19164 switch (op[2] & 0x00) 19165 { 19166 case 0x00: 19167 goto op_semantics_147; 19168 break; 19169 } 19170 break; 19171 case 0x49: 19172 GETBYTE (); 19173 switch (op[2] & 0x00) 19174 { 19175 case 0x00: 19176 goto op_semantics_147; 19177 break; 19178 } 19179 break; 19180 case 0x4a: 19181 GETBYTE (); 19182 switch (op[2] & 0x00) 19183 { 19184 case 0x00: 19185 goto op_semantics_147; 19186 break; 19187 } 19188 break; 19189 case 0x4b: 19190 GETBYTE (); 19191 switch (op[2] & 0x00) 19192 { 19193 case 0x00: 19194 goto op_semantics_147; 19195 break; 19196 } 19197 break; 19198 case 0x4c: 19199 GETBYTE (); 19200 switch (op[2] & 0x00) 19201 { 19202 case 0x00: 19203 goto op_semantics_147; 19204 break; 19205 } 19206 break; 19207 case 0x4d: 19208 GETBYTE (); 19209 switch (op[2] & 0x00) 19210 { 19211 case 0x00: 19212 goto op_semantics_147; 19213 break; 19214 } 19215 break; 19216 case 0x4e: 19217 GETBYTE (); 19218 switch (op[2] & 0x00) 19219 { 19220 case 0x00: 19221 goto op_semantics_147; 19222 break; 19223 } 19224 break; 19225 case 0x4f: 19226 GETBYTE (); 19227 switch (op[2] & 0x00) 19228 { 19229 case 0x00: 19230 goto op_semantics_147; 19231 break; 19232 } 19233 break; 19234 case 0x50: 19235 GETBYTE (); 19236 switch (op[2] & 0x00) 19237 { 19238 case 0x00: 19239 op_semantics_148: 19240 { 19241 /** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */ 19242 #line 465 "rx-decode.opc" 19243 int rdst AU = op[1] & 0x0f; 19244 #line 465 "rx-decode.opc" 19245 int srca AU = (op[2] >> 4) & 0x0f; 19246 #line 465 "rx-decode.opc" 19247 int srcb AU = op[2] & 0x0f; 19248 if (trace) 19249 { 19250 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 19251 "/** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */", 19252 op[0], op[1], op[2]); 19253 printf (" rdst = 0x%x,", rdst); 19254 printf (" srca = 0x%x,", srca); 19255 printf (" srcb = 0x%x\n", srcb); 19256 } 19257 SYNTAX("or %2, %1, %0"); 19258 #line 465 "rx-decode.opc" 19259 ID(or); DR(rdst); SR(srcb); S2R(srca); F__SZ_; 19260 19261 /*----------------------------------------------------------------------*/ 19262 /* XOR */ 19263 19264 } 19265 break; 19266 } 19267 break; 19268 case 0x51: 19269 GETBYTE (); 19270 switch (op[2] & 0x00) 19271 { 19272 case 0x00: 19273 goto op_semantics_148; 19274 break; 19275 } 19276 break; 19277 case 0x52: 19278 GETBYTE (); 19279 switch (op[2] & 0x00) 19280 { 19281 case 0x00: 19282 goto op_semantics_148; 19283 break; 19284 } 19285 break; 19286 case 0x53: 19287 GETBYTE (); 19288 switch (op[2] & 0x00) 19289 { 19290 case 0x00: 19291 goto op_semantics_148; 19292 break; 19293 } 19294 break; 19295 case 0x54: 19296 GETBYTE (); 19297 switch (op[2] & 0x00) 19298 { 19299 case 0x00: 19300 goto op_semantics_148; 19301 break; 19302 } 19303 break; 19304 case 0x55: 19305 GETBYTE (); 19306 switch (op[2] & 0x00) 19307 { 19308 case 0x00: 19309 goto op_semantics_148; 19310 break; 19311 } 19312 break; 19313 case 0x56: 19314 GETBYTE (); 19315 switch (op[2] & 0x00) 19316 { 19317 case 0x00: 19318 goto op_semantics_148; 19319 break; 19320 } 19321 break; 19322 case 0x57: 19323 GETBYTE (); 19324 switch (op[2] & 0x00) 19325 { 19326 case 0x00: 19327 goto op_semantics_148; 19328 break; 19329 } 19330 break; 19331 case 0x58: 19332 GETBYTE (); 19333 switch (op[2] & 0x00) 19334 { 19335 case 0x00: 19336 goto op_semantics_148; 19337 break; 19338 } 19339 break; 19340 case 0x59: 19341 GETBYTE (); 19342 switch (op[2] & 0x00) 19343 { 19344 case 0x00: 19345 goto op_semantics_148; 19346 break; 19347 } 19348 break; 19349 case 0x5a: 19350 GETBYTE (); 19351 switch (op[2] & 0x00) 19352 { 19353 case 0x00: 19354 goto op_semantics_148; 19355 break; 19356 } 19357 break; 19358 case 0x5b: 19359 GETBYTE (); 19360 switch (op[2] & 0x00) 19361 { 19362 case 0x00: 19363 goto op_semantics_148; 19364 break; 19365 } 19366 break; 19367 case 0x5c: 19368 GETBYTE (); 19369 switch (op[2] & 0x00) 19370 { 19371 case 0x00: 19372 goto op_semantics_148; 19373 break; 19374 } 19375 break; 19376 case 0x5d: 19377 GETBYTE (); 19378 switch (op[2] & 0x00) 19379 { 19380 case 0x00: 19381 goto op_semantics_148; 19382 break; 19383 } 19384 break; 19385 case 0x5e: 19386 GETBYTE (); 19387 switch (op[2] & 0x00) 19388 { 19389 case 0x00: 19390 goto op_semantics_148; 19391 break; 19392 } 19393 break; 19394 case 0x5f: 19395 GETBYTE (); 19396 switch (op[2] & 0x00) 19397 { 19398 case 0x00: 19399 goto op_semantics_148; 19400 break; 19401 } 19402 break; 19403 case 0x60: 19404 GETBYTE (); 19405 switch (op[2] & 0x00) 19406 { 19407 case 0x00: 19408 op_semantics_149: 19409 { 19410 /** 1111 1111 0110 rdst srca srcb xor %2, %1, %0 */ 19411 #line 1146 "rx-decode.opc" 19412 int rdst AU = op[1] & 0x0f; 19413 #line 1146 "rx-decode.opc" 19414 int srca AU = (op[2] >> 4) & 0x0f; 19415 #line 1146 "rx-decode.opc" 19416 int srcb AU = op[2] & 0x0f; 19417 if (trace) 19418 { 19419 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 19420 "/** 1111 1111 0110 rdst srca srcb xor %2, %1, %0 */", 19421 op[0], op[1], op[2]); 19422 printf (" rdst = 0x%x,", rdst); 19423 printf (" srca = 0x%x,", srca); 19424 printf (" srcb = 0x%x\n", srcb); 19425 } 19426 SYNTAX("xor %2, %1, %0"); 19427 #line 1146 "rx-decode.opc" 19428 ID(xor); DR(rdst); SR(srcb); S2R(srca); F__SZ_; 19429 19430 } 19431 break; 19432 } 19433 break; 19434 case 0x61: 19435 GETBYTE (); 19436 switch (op[2] & 0x00) 19437 { 19438 case 0x00: 19439 goto op_semantics_149; 19440 break; 19441 } 19442 break; 19443 case 0x62: 19444 GETBYTE (); 19445 switch (op[2] & 0x00) 19446 { 19447 case 0x00: 19448 goto op_semantics_149; 19449 break; 19450 } 19451 break; 19452 case 0x63: 19453 GETBYTE (); 19454 switch (op[2] & 0x00) 19455 { 19456 case 0x00: 19457 goto op_semantics_149; 19458 break; 19459 } 19460 break; 19461 case 0x64: 19462 GETBYTE (); 19463 switch (op[2] & 0x00) 19464 { 19465 case 0x00: 19466 goto op_semantics_149; 19467 break; 19468 } 19469 break; 19470 case 0x65: 19471 GETBYTE (); 19472 switch (op[2] & 0x00) 19473 { 19474 case 0x00: 19475 goto op_semantics_149; 19476 break; 19477 } 19478 break; 19479 case 0x66: 19480 GETBYTE (); 19481 switch (op[2] & 0x00) 19482 { 19483 case 0x00: 19484 goto op_semantics_149; 19485 break; 19486 } 19487 break; 19488 case 0x67: 19489 GETBYTE (); 19490 switch (op[2] & 0x00) 19491 { 19492 case 0x00: 19493 goto op_semantics_149; 19494 break; 19495 } 19496 break; 19497 case 0x68: 19498 GETBYTE (); 19499 switch (op[2] & 0x00) 19500 { 19501 case 0x00: 19502 goto op_semantics_149; 19503 break; 19504 } 19505 break; 19506 case 0x69: 19507 GETBYTE (); 19508 switch (op[2] & 0x00) 19509 { 19510 case 0x00: 19511 goto op_semantics_149; 19512 break; 19513 } 19514 break; 19515 case 0x6a: 19516 GETBYTE (); 19517 switch (op[2] & 0x00) 19518 { 19519 case 0x00: 19520 goto op_semantics_149; 19521 break; 19522 } 19523 break; 19524 case 0x6b: 19525 GETBYTE (); 19526 switch (op[2] & 0x00) 19527 { 19528 case 0x00: 19529 goto op_semantics_149; 19530 break; 19531 } 19532 break; 19533 case 0x6c: 19534 GETBYTE (); 19535 switch (op[2] & 0x00) 19536 { 19537 case 0x00: 19538 goto op_semantics_149; 19539 break; 19540 } 19541 break; 19542 case 0x6d: 19543 GETBYTE (); 19544 switch (op[2] & 0x00) 19545 { 19546 case 0x00: 19547 goto op_semantics_149; 19548 break; 19549 } 19550 break; 19551 case 0x6e: 19552 GETBYTE (); 19553 switch (op[2] & 0x00) 19554 { 19555 case 0x00: 19556 goto op_semantics_149; 19557 break; 19558 } 19559 break; 19560 case 0x6f: 19561 GETBYTE (); 19562 switch (op[2] & 0x00) 19563 { 19564 case 0x00: 19565 goto op_semantics_149; 19566 break; 19567 } 19568 break; 19569 case 0x80: 19570 GETBYTE (); 19571 switch (op[2] & 0x00) 19572 { 19573 case 0x00: 19574 op_semantics_150: 19575 { 19576 /** 1111 1111 1000 rdst srca srcb fsub %2, %1, %0 */ 19577 #line 1125 "rx-decode.opc" 19578 int rdst AU = op[1] & 0x0f; 19579 #line 1125 "rx-decode.opc" 19580 int srca AU = (op[2] >> 4) & 0x0f; 19581 #line 1125 "rx-decode.opc" 19582 int srcb AU = op[2] & 0x0f; 19583 if (trace) 19584 { 19585 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 19586 "/** 1111 1111 1000 rdst srca srcb fsub %2, %1, %0 */", 19587 op[0], op[1], op[2]); 19588 printf (" rdst = 0x%x,", rdst); 19589 printf (" srca = 0x%x,", srca); 19590 printf (" srcb = 0x%x\n", srcb); 19591 } 19592 SYNTAX("fsub %2, %1, %0"); 19593 #line 1125 "rx-decode.opc" 19594 ID(fsub); DR(rdst); SR(srcb); S2R(srca); F__SZ_; 19595 19596 } 19597 break; 19598 } 19599 break; 19600 case 0x81: 19601 GETBYTE (); 19602 switch (op[2] & 0x00) 19603 { 19604 case 0x00: 19605 goto op_semantics_150; 19606 break; 19607 } 19608 break; 19609 case 0x82: 19610 GETBYTE (); 19611 switch (op[2] & 0x00) 19612 { 19613 case 0x00: 19614 goto op_semantics_150; 19615 break; 19616 } 19617 break; 19618 case 0x83: 19619 GETBYTE (); 19620 switch (op[2] & 0x00) 19621 { 19622 case 0x00: 19623 goto op_semantics_150; 19624 break; 19625 } 19626 break; 19627 case 0x84: 19628 GETBYTE (); 19629 switch (op[2] & 0x00) 19630 { 19631 case 0x00: 19632 goto op_semantics_150; 19633 break; 19634 } 19635 break; 19636 case 0x85: 19637 GETBYTE (); 19638 switch (op[2] & 0x00) 19639 { 19640 case 0x00: 19641 goto op_semantics_150; 19642 break; 19643 } 19644 break; 19645 case 0x86: 19646 GETBYTE (); 19647 switch (op[2] & 0x00) 19648 { 19649 case 0x00: 19650 goto op_semantics_150; 19651 break; 19652 } 19653 break; 19654 case 0x87: 19655 GETBYTE (); 19656 switch (op[2] & 0x00) 19657 { 19658 case 0x00: 19659 goto op_semantics_150; 19660 break; 19661 } 19662 break; 19663 case 0x88: 19664 GETBYTE (); 19665 switch (op[2] & 0x00) 19666 { 19667 case 0x00: 19668 goto op_semantics_150; 19669 break; 19670 } 19671 break; 19672 case 0x89: 19673 GETBYTE (); 19674 switch (op[2] & 0x00) 19675 { 19676 case 0x00: 19677 goto op_semantics_150; 19678 break; 19679 } 19680 break; 19681 case 0x8a: 19682 GETBYTE (); 19683 switch (op[2] & 0x00) 19684 { 19685 case 0x00: 19686 goto op_semantics_150; 19687 break; 19688 } 19689 break; 19690 case 0x8b: 19691 GETBYTE (); 19692 switch (op[2] & 0x00) 19693 { 19694 case 0x00: 19695 goto op_semantics_150; 19696 break; 19697 } 19698 break; 19699 case 0x8c: 19700 GETBYTE (); 19701 switch (op[2] & 0x00) 19702 { 19703 case 0x00: 19704 goto op_semantics_150; 19705 break; 19706 } 19707 break; 19708 case 0x8d: 19709 GETBYTE (); 19710 switch (op[2] & 0x00) 19711 { 19712 case 0x00: 19713 goto op_semantics_150; 19714 break; 19715 } 19716 break; 19717 case 0x8e: 19718 GETBYTE (); 19719 switch (op[2] & 0x00) 19720 { 19721 case 0x00: 19722 goto op_semantics_150; 19723 break; 19724 } 19725 break; 19726 case 0x8f: 19727 GETBYTE (); 19728 switch (op[2] & 0x00) 19729 { 19730 case 0x00: 19731 goto op_semantics_150; 19732 break; 19733 } 19734 break; 19735 case 0xa0: 19736 GETBYTE (); 19737 switch (op[2] & 0x00) 19738 { 19739 case 0x00: 19740 op_semantics_151: 19741 { 19742 /** 1111 1111 1010 rdst srca srcb fadd %2, %1, %0 */ 19743 #line 1122 "rx-decode.opc" 19744 int rdst AU = op[1] & 0x0f; 19745 #line 1122 "rx-decode.opc" 19746 int srca AU = (op[2] >> 4) & 0x0f; 19747 #line 1122 "rx-decode.opc" 19748 int srcb AU = op[2] & 0x0f; 19749 if (trace) 19750 { 19751 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 19752 "/** 1111 1111 1010 rdst srca srcb fadd %2, %1, %0 */", 19753 op[0], op[1], op[2]); 19754 printf (" rdst = 0x%x,", rdst); 19755 printf (" srca = 0x%x,", srca); 19756 printf (" srcb = 0x%x\n", srcb); 19757 } 19758 SYNTAX("fadd %2, %1, %0"); 19759 #line 1122 "rx-decode.opc" 19760 ID(fadd); DR(rdst); SR(srcb); S2R(srca); F__SZ_; 19761 19762 } 19763 break; 19764 } 19765 break; 19766 case 0xa1: 19767 GETBYTE (); 19768 switch (op[2] & 0x00) 19769 { 19770 case 0x00: 19771 goto op_semantics_151; 19772 break; 19773 } 19774 break; 19775 case 0xa2: 19776 GETBYTE (); 19777 switch (op[2] & 0x00) 19778 { 19779 case 0x00: 19780 goto op_semantics_151; 19781 break; 19782 } 19783 break; 19784 case 0xa3: 19785 GETBYTE (); 19786 switch (op[2] & 0x00) 19787 { 19788 case 0x00: 19789 goto op_semantics_151; 19790 break; 19791 } 19792 break; 19793 case 0xa4: 19794 GETBYTE (); 19795 switch (op[2] & 0x00) 19796 { 19797 case 0x00: 19798 goto op_semantics_151; 19799 break; 19800 } 19801 break; 19802 case 0xa5: 19803 GETBYTE (); 19804 switch (op[2] & 0x00) 19805 { 19806 case 0x00: 19807 goto op_semantics_151; 19808 break; 19809 } 19810 break; 19811 case 0xa6: 19812 GETBYTE (); 19813 switch (op[2] & 0x00) 19814 { 19815 case 0x00: 19816 goto op_semantics_151; 19817 break; 19818 } 19819 break; 19820 case 0xa7: 19821 GETBYTE (); 19822 switch (op[2] & 0x00) 19823 { 19824 case 0x00: 19825 goto op_semantics_151; 19826 break; 19827 } 19828 break; 19829 case 0xa8: 19830 GETBYTE (); 19831 switch (op[2] & 0x00) 19832 { 19833 case 0x00: 19834 goto op_semantics_151; 19835 break; 19836 } 19837 break; 19838 case 0xa9: 19839 GETBYTE (); 19840 switch (op[2] & 0x00) 19841 { 19842 case 0x00: 19843 goto op_semantics_151; 19844 break; 19845 } 19846 break; 19847 case 0xaa: 19848 GETBYTE (); 19849 switch (op[2] & 0x00) 19850 { 19851 case 0x00: 19852 goto op_semantics_151; 19853 break; 19854 } 19855 break; 19856 case 0xab: 19857 GETBYTE (); 19858 switch (op[2] & 0x00) 19859 { 19860 case 0x00: 19861 goto op_semantics_151; 19862 break; 19863 } 19864 break; 19865 case 0xac: 19866 GETBYTE (); 19867 switch (op[2] & 0x00) 19868 { 19869 case 0x00: 19870 goto op_semantics_151; 19871 break; 19872 } 19873 break; 19874 case 0xad: 19875 GETBYTE (); 19876 switch (op[2] & 0x00) 19877 { 19878 case 0x00: 19879 goto op_semantics_151; 19880 break; 19881 } 19882 break; 19883 case 0xae: 19884 GETBYTE (); 19885 switch (op[2] & 0x00) 19886 { 19887 case 0x00: 19888 goto op_semantics_151; 19889 break; 19890 } 19891 break; 19892 case 0xaf: 19893 GETBYTE (); 19894 switch (op[2] & 0x00) 19895 { 19896 case 0x00: 19897 goto op_semantics_151; 19898 break; 19899 } 19900 break; 19901 case 0xb0: 19902 GETBYTE (); 19903 switch (op[2] & 0x00) 19904 { 19905 case 0x00: 19906 op_semantics_152: 19907 { 19908 /** 1111 1111 1011 rdst srca srcb fmul %2, %1, %0 */ 19909 #line 1128 "rx-decode.opc" 19910 int rdst AU = op[1] & 0x0f; 19911 #line 1128 "rx-decode.opc" 19912 int srca AU = (op[2] >> 4) & 0x0f; 19913 #line 1128 "rx-decode.opc" 19914 int srcb AU = op[2] & 0x0f; 19915 if (trace) 19916 { 19917 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 19918 "/** 1111 1111 1011 rdst srca srcb fmul %2, %1, %0 */", 19919 op[0], op[1], op[2]); 19920 printf (" rdst = 0x%x,", rdst); 19921 printf (" srca = 0x%x,", srca); 19922 printf (" srcb = 0x%x\n", srcb); 19923 } 19924 SYNTAX("fmul %2, %1, %0"); 19925 #line 1128 "rx-decode.opc" 19926 ID(fmul); DR(rdst); SR(srcb); S2R(srca); F__SZ_; 19927 19928 } 19929 break; 19930 } 19931 break; 19932 case 0xb1: 19933 GETBYTE (); 19934 switch (op[2] & 0x00) 19935 { 19936 case 0x00: 19937 goto op_semantics_152; 19938 break; 19939 } 19940 break; 19941 case 0xb2: 19942 GETBYTE (); 19943 switch (op[2] & 0x00) 19944 { 19945 case 0x00: 19946 goto op_semantics_152; 19947 break; 19948 } 19949 break; 19950 case 0xb3: 19951 GETBYTE (); 19952 switch (op[2] & 0x00) 19953 { 19954 case 0x00: 19955 goto op_semantics_152; 19956 break; 19957 } 19958 break; 19959 case 0xb4: 19960 GETBYTE (); 19961 switch (op[2] & 0x00) 19962 { 19963 case 0x00: 19964 goto op_semantics_152; 19965 break; 19966 } 19967 break; 19968 case 0xb5: 19969 GETBYTE (); 19970 switch (op[2] & 0x00) 19971 { 19972 case 0x00: 19973 goto op_semantics_152; 19974 break; 19975 } 19976 break; 19977 case 0xb6: 19978 GETBYTE (); 19979 switch (op[2] & 0x00) 19980 { 19981 case 0x00: 19982 goto op_semantics_152; 19983 break; 19984 } 19985 break; 19986 case 0xb7: 19987 GETBYTE (); 19988 switch (op[2] & 0x00) 19989 { 19990 case 0x00: 19991 goto op_semantics_152; 19992 break; 19993 } 19994 break; 19995 case 0xb8: 19996 GETBYTE (); 19997 switch (op[2] & 0x00) 19998 { 19999 case 0x00: 20000 goto op_semantics_152; 20001 break; 20002 } 20003 break; 20004 case 0xb9: 20005 GETBYTE (); 20006 switch (op[2] & 0x00) 20007 { 20008 case 0x00: 20009 goto op_semantics_152; 20010 break; 20011 } 20012 break; 20013 case 0xba: 20014 GETBYTE (); 20015 switch (op[2] & 0x00) 20016 { 20017 case 0x00: 20018 goto op_semantics_152; 20019 break; 20020 } 20021 break; 20022 case 0xbb: 20023 GETBYTE (); 20024 switch (op[2] & 0x00) 20025 { 20026 case 0x00: 20027 goto op_semantics_152; 20028 break; 20029 } 20030 break; 20031 case 0xbc: 20032 GETBYTE (); 20033 switch (op[2] & 0x00) 20034 { 20035 case 0x00: 20036 goto op_semantics_152; 20037 break; 20038 } 20039 break; 20040 case 0xbd: 20041 GETBYTE (); 20042 switch (op[2] & 0x00) 20043 { 20044 case 0x00: 20045 goto op_semantics_152; 20046 break; 20047 } 20048 break; 20049 case 0xbe: 20050 GETBYTE (); 20051 switch (op[2] & 0x00) 20052 { 20053 case 0x00: 20054 goto op_semantics_152; 20055 break; 20056 } 20057 break; 20058 case 0xbf: 20059 GETBYTE (); 20060 switch (op[2] & 0x00) 20061 { 20062 case 0x00: 20063 goto op_semantics_152; 20064 break; 20065 } 20066 break; 20067 default: UNSUPPORTED(); break; 20068 } 20069 break; 20070 default: UNSUPPORTED(); break; 20071 } 20072 #line 1280 "rx-decode.opc" 20073 20074 return rx->n_bytes; 20075 } 20076
Indexes created Wed Mar 25 00:23:37 UTC 2026