1 #line 1 "rx-decode.opc" 2 /* -*- c -*- */ 3 /* Copyright (C) 2012-2018 Free Software Foundation, Inc. 4 Contributed by Red Hat. 5 Written by DJ Delorie. 6 7 This file is part of the GNU opcodes library. 8 9 This library is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3, or (at your option) 12 any later version. 13 14 It is distributed in the hope that it will be useful, but WITHOUT 15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 16 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public 17 License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 22 MA 02110-1301, USA. */ 23 24 #include "sysdep.h" 25 #include <stdio.h> 26 #include <stdlib.h> 27 #include <string.h> 28 #include "ansidecl.h" 29 #include "opcode/rx.h" 30 #include "libiberty.h" 31 32 #define RX_OPCODE_BIG_ENDIAN 0 33 34 typedef struct 35 { 36 RX_Opcode_Decoded * rx; 37 int (* getbyte)(void *); 38 void * ptr; 39 unsigned char * op; 40 } LocalData; 41 42 static int trace = 0; 43 44 #define BSIZE 0 45 #define WSIZE 1 46 #define LSIZE 2 47 48 /* These are for when the upper bits are "don't care" or "undefined". */ 49 static int bwl[4] = 50 { 51 RX_Byte, 52 RX_Word, 53 RX_Long, 54 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */ 55 }; 56 57 static int sbwl[4] = 58 { 59 RX_SByte, 60 RX_SWord, 61 RX_Long, 62 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */ 63 }; 64 65 static int ubw[4] = 66 { 67 RX_UByte, 68 RX_UWord, 69 RX_Bad_Size,/* Bogus instructions can have a size field set to 2. */ 70 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */ 71 }; 72 73 static int memex[4] = 74 { 75 RX_SByte, 76 RX_SWord, 77 RX_Long, 78 RX_UWord 79 }; 80 81 #define ID(x) rx->id = RXO_##x 82 #define OP(n,t,r,a) (rx->op[n].type = t, \ 83 rx->op[n].reg = r, \ 84 rx->op[n].addend = a ) 85 #define OPs(n,t,r,a,s) (OP (n,t,r,a), \ 86 rx->op[n].size = s ) 87 88 /* This is for the BWL and BW bitfields. */ 89 static int SCALE[] = { 1, 2, 4, 0 }; 90 /* This is for the prefix size enum. */ 91 static int PSCALE[] = { 4, 1, 1, 1, 2, 2, 2, 3, 4 }; 92 93 #define GET_SCALE(_indx) ((unsigned)(_indx) < ARRAY_SIZE (SCALE) ? SCALE[(_indx)] : 0) 94 #define GET_PSCALE(_indx) ((unsigned)(_indx) < ARRAY_SIZE (PSCALE) ? PSCALE[(_indx)] : 0) 95 96 static int flagmap[] = {0, 1, 2, 3, 0, 0, 0, 0, 97 16, 17, 0, 0, 0, 0, 0, 0 }; 98 99 static int dsp3map[] = { 8, 9, 10, 3, 4, 5, 6, 7 }; 100 101 /* 102 *C a constant (immediate) c 103 *R A register 104 *I Register indirect, no offset 105 *Is Register indirect, with offset 106 *D standard displacement: type (r,[r],dsp8,dsp16 code), register, BWL code 107 *P standard displacement: type (r,[r]), reg, assumes UByte 108 *Pm memex displacement: type (r,[r]), reg, memex code 109 *cc condition code. */ 110 111 #define DC(c) OP (0, RX_Operand_Immediate, 0, c) 112 #define DR(r) OP (0, RX_Operand_Register, r, 0) 113 #define DI(r,a) OP (0, RX_Operand_Indirect, r, a) 114 #define DIs(r,a,s) OP (0, RX_Operand_Indirect, r, (a) * GET_SCALE (s)) 115 #define DD(t,r,s) rx_disp (0, t, r, bwl[s], ld); 116 #define DF(r) OP (0, RX_Operand_Flag, flagmap[r], 0) 117 118 #define SC(i) OP (1, RX_Operand_Immediate, 0, i) 119 #define SR(r) OP (1, RX_Operand_Register, r, 0) 120 #define SRR(r) OP (1, RX_Operand_TwoReg, r, 0) 121 #define SI(r,a) OP (1, RX_Operand_Indirect, r, a) 122 #define SIs(r,a,s) OP (1, RX_Operand_Indirect, r, (a) * GET_SCALE (s)) 123 #define SD(t,r,s) rx_disp (1, t, r, bwl[s], ld); 124 #define SP(t,r) rx_disp (1, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 1); 125 #define SPm(t,r,m) rx_disp (1, t, r, memex[m], ld); rx->op[1].size = memex[m]; 126 #define Scc(cc) OP (1, RX_Operand_Condition, cc, 0) 127 128 #define S2C(i) OP (2, RX_Operand_Immediate, 0, i) 129 #define S2R(r) OP (2, RX_Operand_Register, r, 0) 130 #define S2I(r,a) OP (2, RX_Operand_Indirect, r, a) 131 #define S2Is(r,a,s) OP (2, RX_Operand_Indirect, r, (a) * GET_SCALE (s)) 132 #define S2D(t,r,s) rx_disp (2, t, r, bwl[s], ld); 133 #define S2P(t,r) rx_disp (2, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 2); 134 #define S2Pm(t,r,m) rx_disp (2, t, r, memex[m], ld); rx->op[2].size = memex[m]; 135 #define S2cc(cc) OP (2, RX_Operand_Condition, cc, 0) 136 137 #define BWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = bwl[sz] 138 #define sBWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = sbwl[sz] 139 #define uBW(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = ubw[sz] 140 #define P(t, n) rx->op[n].size = (t!=3) ? RX_UByte : RX_Long; 141 142 #define F(f) store_flags(rx, f) 143 144 #define AU ATTRIBUTE_UNUSED 145 #define GETBYTE() (ld->op [ld->rx->n_bytes++] = ld->getbyte (ld->ptr)) 146 147 #define SYNTAX(x) rx->syntax = x 148 149 #define UNSUPPORTED() \ 150 rx->syntax = "*unknown*" 151 152 #define IMM(sf) immediate (sf, 0, ld) 153 #define IMMex(sf) immediate (sf, 1, ld) 154 155 static int 156 immediate (int sfield, int ex, LocalData * ld) 157 { 158 unsigned long i = 0, j; 159 160 switch (sfield) 161 { 162 #define B ((unsigned long) GETBYTE()) 163 case 0: 164 #if RX_OPCODE_BIG_ENDIAN 165 i = B; 166 if (ex && (i & 0x80)) 167 i -= 0x100; 168 i <<= 24; 169 i |= B << 16; 170 i |= B << 8; 171 i |= B; 172 #else 173 i = B; 174 i |= B << 8; 175 i |= B << 16; 176 j = B; 177 if (ex && (j & 0x80)) 178 j -= 0x100; 179 i |= j << 24; 180 #endif 181 break; 182 case 3: 183 #if RX_OPCODE_BIG_ENDIAN 184 i = B << 16; 185 i |= B << 8; 186 i |= B; 187 #else 188 i = B; 189 i |= B << 8; 190 i |= B << 16; 191 #endif 192 if (ex && (i & 0x800000)) 193 i -= 0x1000000; 194 break; 195 case 2: 196 #if RX_OPCODE_BIG_ENDIAN 197 i |= B << 8; 198 i |= B; 199 #else 200 i |= B; 201 i |= B << 8; 202 #endif 203 if (ex && (i & 0x8000)) 204 i -= 0x10000; 205 break; 206 case 1: 207 i |= B; 208 if (ex && (i & 0x80)) 209 i -= 0x100; 210 break; 211 default: 212 abort(); 213 } 214 return i; 215 } 216 217 static void 218 rx_disp (int n, int type, int reg, unsigned int size, LocalData * ld) 219 { 220 int disp; 221 222 ld->rx->op[n].reg = reg; 223 switch (type) 224 { 225 case 3: 226 ld->rx->op[n].type = RX_Operand_Register; 227 break; 228 case 0: 229 ld->rx->op[n].type = RX_Operand_Zero_Indirect; 230 ld->rx->op[n].addend = 0; 231 break; 232 case 1: 233 ld->rx->op[n].type = RX_Operand_Indirect; 234 disp = GETBYTE (); 235 ld->rx->op[n].addend = disp * GET_PSCALE (size); 236 break; 237 case 2: 238 ld->rx->op[n].type = RX_Operand_Indirect; 239 disp = GETBYTE (); 240 #if RX_OPCODE_BIG_ENDIAN 241 disp = disp * 256 + GETBYTE (); 242 #else 243 disp = disp + GETBYTE () * 256; 244 #endif 245 ld->rx->op[n].addend = disp * GET_PSCALE (size); 246 break; 247 default: 248 abort (); 249 } 250 } 251 252 #define xO 8 253 #define xS 4 254 #define xZ 2 255 #define xC 1 256 257 #define F_____ 258 #define F___ZC rx->flags_0 = rx->flags_s = xZ|xC; 259 #define F__SZ_ rx->flags_0 = rx->flags_s = xS|xZ; 260 #define F__SZC rx->flags_0 = rx->flags_s = xS|xZ|xC; 261 #define F_0SZC rx->flags_0 = xO|xS|xZ|xC; rx->flags_s = xS|xZ|xC; 262 #define F_O___ rx->flags_0 = rx->flags_s = xO; 263 #define F_OS__ rx->flags_0 = rx->flags_s = xO|xS; 264 #define F_OSZ_ rx->flags_0 = rx->flags_s = xO|xS|xZ; 265 #define F_OSZC rx->flags_0 = rx->flags_s = xO|xS|xZ|xC; 266 267 int 268 rx_decode_opcode (unsigned long pc AU, 269 RX_Opcode_Decoded * rx, 270 int (* getbyte)(void *), 271 void * ptr) 272 { 273 LocalData lds, * ld = &lds; 274 unsigned char op[20] = {0}; 275 276 lds.rx = rx; 277 lds.getbyte = getbyte; 278 lds.ptr = ptr; 279 lds.op = op; 280 281 memset (rx, 0, sizeof (*rx)); 282 BWL(LSIZE); 283 284 285 /*----------------------------------------------------------------------*/ 286 /* MOV */ 287 288 GETBYTE (); 289 switch (op[0] & 0xff) 290 { 291 case 0x00: 292 { 293 /** 0000 0000 brk */ 294 if (trace) 295 { 296 printf ("\033[33m%s\033[0m %02x\n", 297 "/** 0000 0000 brk */", 298 op[0]); 299 } 300 SYNTAX("brk"); 301 #line 1029 "rx-decode.opc" 302 ID(brk); 303 304 } 305 break; 306 case 0x01: 307 { 308 /** 0000 0001 dbt */ 309 if (trace) 310 { 311 printf ("\033[33m%s\033[0m %02x\n", 312 "/** 0000 0001 dbt */", 313 op[0]); 314 } 315 SYNTAX("dbt"); 316 #line 1032 "rx-decode.opc" 317 ID(dbt); 318 319 } 320 break; 321 case 0x02: 322 { 323 /** 0000 0010 rts */ 324 if (trace) 325 { 326 printf ("\033[33m%s\033[0m %02x\n", 327 "/** 0000 0010 rts */", 328 op[0]); 329 } 330 SYNTAX("rts"); 331 #line 810 "rx-decode.opc" 332 ID(rts); 333 334 /*----------------------------------------------------------------------*/ 335 /* NOP */ 336 337 } 338 break; 339 case 0x03: 340 { 341 /** 0000 0011 nop */ 342 if (trace) 343 { 344 printf ("\033[33m%s\033[0m %02x\n", 345 "/** 0000 0011 nop */", 346 op[0]); 347 } 348 SYNTAX("nop"); 349 #line 816 "rx-decode.opc" 350 ID(nop); 351 352 /*----------------------------------------------------------------------*/ 353 /* STRING FUNCTIONS */ 354 355 } 356 break; 357 case 0x04: 358 { 359 /** 0000 0100 bra.a %a0 */ 360 if (trace) 361 { 362 printf ("\033[33m%s\033[0m %02x\n", 363 "/** 0000 0100 bra.a %a0 */", 364 op[0]); 365 } 366 SYNTAX("bra.a %a0"); 367 #line 788 "rx-decode.opc" 368 ID(branch); DC(pc + IMMex(3)); 369 370 } 371 break; 372 case 0x05: 373 { 374 /** 0000 0101 bsr.a %a0 */ 375 if (trace) 376 { 377 printf ("\033[33m%s\033[0m %02x\n", 378 "/** 0000 0101 bsr.a %a0 */", 379 op[0]); 380 } 381 SYNTAX("bsr.a %a0"); 382 #line 804 "rx-decode.opc" 383 ID(jsr); DC(pc + IMMex(3)); 384 385 } 386 break; 387 case 0x06: 388 GETBYTE (); 389 switch (op[1] & 0xff) 390 { 391 case 0x00: 392 GETBYTE (); 393 switch (op[2] & 0x00) 394 { 395 case 0x00: 396 op_semantics_1: 397 { 398 /** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */ 399 #line 546 "rx-decode.opc" 400 int mx AU = (op[1] >> 6) & 0x03; 401 #line 546 "rx-decode.opc" 402 int ss AU = op[1] & 0x03; 403 #line 546 "rx-decode.opc" 404 int rsrc AU = (op[2] >> 4) & 0x0f; 405 #line 546 "rx-decode.opc" 406 int rdst AU = op[2] & 0x0f; 407 if (trace) 408 { 409 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 410 "/** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */", 411 op[0], op[1], op[2]); 412 printf (" mx = 0x%x,", mx); 413 printf (" ss = 0x%x,", ss); 414 printf (" rsrc = 0x%x,", rsrc); 415 printf (" rdst = 0x%x\n", rdst); 416 } 417 SYNTAX("sub %2%S2, %1"); 418 #line 546 "rx-decode.opc" 419 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F_OSZC; 420 421 } 422 break; 423 } 424 break; 425 case 0x01: 426 GETBYTE (); 427 switch (op[2] & 0x00) 428 { 429 case 0x00: 430 goto op_semantics_1; 431 break; 432 } 433 break; 434 case 0x02: 435 GETBYTE (); 436 switch (op[2] & 0x00) 437 { 438 case 0x00: 439 goto op_semantics_1; 440 break; 441 } 442 break; 443 case 0x03: 444 GETBYTE (); 445 switch (op[2] & 0x00) 446 { 447 case 0x00: 448 goto op_semantics_1; 449 break; 450 } 451 break; 452 case 0x04: 453 GETBYTE (); 454 switch (op[2] & 0x00) 455 { 456 case 0x00: 457 op_semantics_2: 458 { 459 /** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */ 460 #line 534 "rx-decode.opc" 461 int mx AU = (op[1] >> 6) & 0x03; 462 #line 534 "rx-decode.opc" 463 int ss AU = op[1] & 0x03; 464 #line 534 "rx-decode.opc" 465 int rsrc AU = (op[2] >> 4) & 0x0f; 466 #line 534 "rx-decode.opc" 467 int rdst AU = op[2] & 0x0f; 468 if (trace) 469 { 470 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 471 "/** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */", 472 op[0], op[1], op[2]); 473 printf (" mx = 0x%x,", mx); 474 printf (" ss = 0x%x,", ss); 475 printf (" rsrc = 0x%x,", rsrc); 476 printf (" rdst = 0x%x\n", rdst); 477 } 478 SYNTAX("cmp %2%S2, %1"); 479 #line 534 "rx-decode.opc" 480 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F_OSZC; 481 482 /*----------------------------------------------------------------------*/ 483 /* SUB */ 484 485 } 486 break; 487 } 488 break; 489 case 0x05: 490 GETBYTE (); 491 switch (op[2] & 0x00) 492 { 493 case 0x00: 494 goto op_semantics_2; 495 break; 496 } 497 break; 498 case 0x06: 499 GETBYTE (); 500 switch (op[2] & 0x00) 501 { 502 case 0x00: 503 goto op_semantics_2; 504 break; 505 } 506 break; 507 case 0x07: 508 GETBYTE (); 509 switch (op[2] & 0x00) 510 { 511 case 0x00: 512 goto op_semantics_2; 513 break; 514 } 515 break; 516 case 0x08: 517 GETBYTE (); 518 switch (op[2] & 0x00) 519 { 520 case 0x00: 521 op_semantics_3: 522 { 523 /** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */ 524 #line 510 "rx-decode.opc" 525 int mx AU = (op[1] >> 6) & 0x03; 526 #line 510 "rx-decode.opc" 527 int ss AU = op[1] & 0x03; 528 #line 510 "rx-decode.opc" 529 int rsrc AU = (op[2] >> 4) & 0x0f; 530 #line 510 "rx-decode.opc" 531 int rdst AU = op[2] & 0x0f; 532 if (trace) 533 { 534 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 535 "/** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */", 536 op[0], op[1], op[2]); 537 printf (" mx = 0x%x,", mx); 538 printf (" ss = 0x%x,", ss); 539 printf (" rsrc = 0x%x,", rsrc); 540 printf (" rdst = 0x%x\n", rdst); 541 } 542 SYNTAX("add %1%S1, %0"); 543 #line 510 "rx-decode.opc" 544 ID(add); SPm(ss, rsrc, mx); DR(rdst); F_OSZC; 545 546 } 547 break; 548 } 549 break; 550 case 0x09: 551 GETBYTE (); 552 switch (op[2] & 0x00) 553 { 554 case 0x00: 555 goto op_semantics_3; 556 break; 557 } 558 break; 559 case 0x0a: 560 GETBYTE (); 561 switch (op[2] & 0x00) 562 { 563 case 0x00: 564 goto op_semantics_3; 565 break; 566 } 567 break; 568 case 0x0b: 569 GETBYTE (); 570 switch (op[2] & 0x00) 571 { 572 case 0x00: 573 goto op_semantics_3; 574 break; 575 } 576 break; 577 case 0x0c: 578 GETBYTE (); 579 switch (op[2] & 0x00) 580 { 581 case 0x00: 582 op_semantics_4: 583 { 584 /** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */ 585 #line 653 "rx-decode.opc" 586 int mx AU = (op[1] >> 6) & 0x03; 587 #line 653 "rx-decode.opc" 588 int ss AU = op[1] & 0x03; 589 #line 653 "rx-decode.opc" 590 int rsrc AU = (op[2] >> 4) & 0x0f; 591 #line 653 "rx-decode.opc" 592 int rdst AU = op[2] & 0x0f; 593 if (trace) 594 { 595 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 596 "/** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */", 597 op[0], op[1], op[2]); 598 printf (" mx = 0x%x,", mx); 599 printf (" ss = 0x%x,", ss); 600 printf (" rsrc = 0x%x,", rsrc); 601 printf (" rdst = 0x%x\n", rdst); 602 } 603 SYNTAX("mul %1%S1, %0"); 604 #line 653 "rx-decode.opc" 605 ID(mul); SPm(ss, rsrc, mx); DR(rdst); F_____; 606 607 } 608 break; 609 } 610 break; 611 case 0x0d: 612 GETBYTE (); 613 switch (op[2] & 0x00) 614 { 615 case 0x00: 616 goto op_semantics_4; 617 break; 618 } 619 break; 620 case 0x0e: 621 GETBYTE (); 622 switch (op[2] & 0x00) 623 { 624 case 0x00: 625 goto op_semantics_4; 626 break; 627 } 628 break; 629 case 0x0f: 630 GETBYTE (); 631 switch (op[2] & 0x00) 632 { 633 case 0x00: 634 goto op_semantics_4; 635 break; 636 } 637 break; 638 case 0x10: 639 GETBYTE (); 640 switch (op[2] & 0x00) 641 { 642 case 0x00: 643 op_semantics_5: 644 { 645 /** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */ 646 #line 423 "rx-decode.opc" 647 int mx AU = (op[1] >> 6) & 0x03; 648 #line 423 "rx-decode.opc" 649 int ss AU = op[1] & 0x03; 650 #line 423 "rx-decode.opc" 651 int rsrc AU = (op[2] >> 4) & 0x0f; 652 #line 423 "rx-decode.opc" 653 int rdst AU = op[2] & 0x0f; 654 if (trace) 655 { 656 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 657 "/** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */", 658 op[0], op[1], op[2]); 659 printf (" mx = 0x%x,", mx); 660 printf (" ss = 0x%x,", ss); 661 printf (" rsrc = 0x%x,", rsrc); 662 printf (" rdst = 0x%x\n", rdst); 663 } 664 SYNTAX("and %1%S1, %0"); 665 #line 423 "rx-decode.opc" 666 ID(and); SPm(ss, rsrc, mx); DR(rdst); F__SZ_; 667 668 } 669 break; 670 } 671 break; 672 case 0x11: 673 GETBYTE (); 674 switch (op[2] & 0x00) 675 { 676 case 0x00: 677 goto op_semantics_5; 678 break; 679 } 680 break; 681 case 0x12: 682 GETBYTE (); 683 switch (op[2] & 0x00) 684 { 685 case 0x00: 686 goto op_semantics_5; 687 break; 688 } 689 break; 690 case 0x13: 691 GETBYTE (); 692 switch (op[2] & 0x00) 693 { 694 case 0x00: 695 goto op_semantics_5; 696 break; 697 } 698 break; 699 case 0x14: 700 GETBYTE (); 701 switch (op[2] & 0x00) 702 { 703 case 0x00: 704 op_semantics_6: 705 { 706 /** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */ 707 #line 441 "rx-decode.opc" 708 int mx AU = (op[1] >> 6) & 0x03; 709 #line 441 "rx-decode.opc" 710 int ss AU = op[1] & 0x03; 711 #line 441 "rx-decode.opc" 712 int rsrc AU = (op[2] >> 4) & 0x0f; 713 #line 441 "rx-decode.opc" 714 int rdst AU = op[2] & 0x0f; 715 if (trace) 716 { 717 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 718 "/** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */", 719 op[0], op[1], op[2]); 720 printf (" mx = 0x%x,", mx); 721 printf (" ss = 0x%x,", ss); 722 printf (" rsrc = 0x%x,", rsrc); 723 printf (" rdst = 0x%x\n", rdst); 724 } 725 SYNTAX("or %1%S1, %0"); 726 #line 441 "rx-decode.opc" 727 ID(or); SPm(ss, rsrc, mx); DR(rdst); F__SZ_; 728 729 } 730 break; 731 } 732 break; 733 case 0x15: 734 GETBYTE (); 735 switch (op[2] & 0x00) 736 { 737 case 0x00: 738 goto op_semantics_6; 739 break; 740 } 741 break; 742 case 0x16: 743 GETBYTE (); 744 switch (op[2] & 0x00) 745 { 746 case 0x00: 747 goto op_semantics_6; 748 break; 749 } 750 break; 751 case 0x17: 752 GETBYTE (); 753 switch (op[2] & 0x00) 754 { 755 case 0x00: 756 goto op_semantics_6; 757 break; 758 } 759 break; 760 case 0x20: 761 GETBYTE (); 762 switch (op[2] & 0xff) 763 { 764 case 0x00: 765 GETBYTE (); 766 switch (op[3] & 0x00) 767 { 768 case 0x00: 769 op_semantics_7: 770 { 771 /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */ 772 #line 559 "rx-decode.opc" 773 int mx AU = (op[1] >> 6) & 0x03; 774 #line 559 "rx-decode.opc" 775 int sp AU = op[1] & 0x03; 776 #line 559 "rx-decode.opc" 777 int rsrc AU = (op[3] >> 4) & 0x0f; 778 #line 559 "rx-decode.opc" 779 int rdst AU = op[3] & 0x0f; 780 if (trace) 781 { 782 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 783 "/** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */", 784 op[0], op[1], op[2], op[3]); 785 printf (" mx = 0x%x,", mx); 786 printf (" sp = 0x%x,", sp); 787 printf (" rsrc = 0x%x,", rsrc); 788 printf (" rdst = 0x%x\n", rdst); 789 } 790 SYNTAX("sbb %1%S1, %0"); 791 #line 559 "rx-decode.opc" 792 ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F_OSZC; 793 794 /*----------------------------------------------------------------------*/ 795 /* ABS */ 796 797 } 798 break; 799 } 800 break; 801 case 0x04: 802 GETBYTE (); 803 switch (op[3] & 0x00) 804 { 805 case 0x00: 806 op_semantics_8: 807 { 808 /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */ 809 #line 598 "rx-decode.opc" 810 int mx AU = (op[1] >> 6) & 0x03; 811 #line 598 "rx-decode.opc" 812 int ss AU = op[1] & 0x03; 813 #line 598 "rx-decode.opc" 814 int rsrc AU = (op[3] >> 4) & 0x0f; 815 #line 598 "rx-decode.opc" 816 int rdst AU = op[3] & 0x0f; 817 if (trace) 818 { 819 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 820 "/** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */", 821 op[0], op[1], op[2], op[3]); 822 printf (" mx = 0x%x,", mx); 823 printf (" ss = 0x%x,", ss); 824 printf (" rsrc = 0x%x,", rsrc); 825 printf (" rdst = 0x%x\n", rdst); 826 } 827 SYNTAX("max %1%S1, %0"); 828 #line 598 "rx-decode.opc" 829 ID(max); SPm(ss, rsrc, mx); DR(rdst); 830 831 /*----------------------------------------------------------------------*/ 832 /* MIN */ 833 834 } 835 break; 836 } 837 break; 838 case 0x05: 839 GETBYTE (); 840 switch (op[3] & 0x00) 841 { 842 case 0x00: 843 op_semantics_9: 844 { 845 /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */ 846 #line 610 "rx-decode.opc" 847 int mx AU = (op[1] >> 6) & 0x03; 848 #line 610 "rx-decode.opc" 849 int ss AU = op[1] & 0x03; 850 #line 610 "rx-decode.opc" 851 int rsrc AU = (op[3] >> 4) & 0x0f; 852 #line 610 "rx-decode.opc" 853 int rdst AU = op[3] & 0x0f; 854 if (trace) 855 { 856 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 857 "/** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */", 858 op[0], op[1], op[2], op[3]); 859 printf (" mx = 0x%x,", mx); 860 printf (" ss = 0x%x,", ss); 861 printf (" rsrc = 0x%x,", rsrc); 862 printf (" rdst = 0x%x\n", rdst); 863 } 864 SYNTAX("min %1%S1, %0"); 865 #line 610 "rx-decode.opc" 866 ID(min); SPm(ss, rsrc, mx); DR(rdst); 867 868 /*----------------------------------------------------------------------*/ 869 /* MUL */ 870 871 } 872 break; 873 } 874 break; 875 case 0x06: 876 GETBYTE (); 877 switch (op[3] & 0x00) 878 { 879 case 0x00: 880 op_semantics_10: 881 { 882 /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */ 883 #line 668 "rx-decode.opc" 884 int mx AU = (op[1] >> 6) & 0x03; 885 #line 668 "rx-decode.opc" 886 int ss AU = op[1] & 0x03; 887 #line 668 "rx-decode.opc" 888 int rsrc AU = (op[3] >> 4) & 0x0f; 889 #line 668 "rx-decode.opc" 890 int rdst AU = op[3] & 0x0f; 891 if (trace) 892 { 893 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 894 "/** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */", 895 op[0], op[1], op[2], op[3]); 896 printf (" mx = 0x%x,", mx); 897 printf (" ss = 0x%x,", ss); 898 printf (" rsrc = 0x%x,", rsrc); 899 printf (" rdst = 0x%x\n", rdst); 900 } 901 SYNTAX("emul %1%S1, %0"); 902 #line 668 "rx-decode.opc" 903 ID(emul); SPm(ss, rsrc, mx); DR(rdst); 904 905 /*----------------------------------------------------------------------*/ 906 /* EMULU */ 907 908 } 909 break; 910 } 911 break; 912 case 0x07: 913 GETBYTE (); 914 switch (op[3] & 0x00) 915 { 916 case 0x00: 917 op_semantics_11: 918 { 919 /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */ 920 #line 680 "rx-decode.opc" 921 int mx AU = (op[1] >> 6) & 0x03; 922 #line 680 "rx-decode.opc" 923 int ss AU = op[1] & 0x03; 924 #line 680 "rx-decode.opc" 925 int rsrc AU = (op[3] >> 4) & 0x0f; 926 #line 680 "rx-decode.opc" 927 int rdst AU = op[3] & 0x0f; 928 if (trace) 929 { 930 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 931 "/** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */", 932 op[0], op[1], op[2], op[3]); 933 printf (" mx = 0x%x,", mx); 934 printf (" ss = 0x%x,", ss); 935 printf (" rsrc = 0x%x,", rsrc); 936 printf (" rdst = 0x%x\n", rdst); 937 } 938 SYNTAX("emulu %1%S1, %0"); 939 #line 680 "rx-decode.opc" 940 ID(emulu); SPm(ss, rsrc, mx); DR(rdst); 941 942 /*----------------------------------------------------------------------*/ 943 /* DIV */ 944 945 } 946 break; 947 } 948 break; 949 case 0x08: 950 GETBYTE (); 951 switch (op[3] & 0x00) 952 { 953 case 0x00: 954 op_semantics_12: 955 { 956 /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */ 957 #line 692 "rx-decode.opc" 958 int mx AU = (op[1] >> 6) & 0x03; 959 #line 692 "rx-decode.opc" 960 int ss AU = op[1] & 0x03; 961 #line 692 "rx-decode.opc" 962 int rsrc AU = (op[3] >> 4) & 0x0f; 963 #line 692 "rx-decode.opc" 964 int rdst AU = op[3] & 0x0f; 965 if (trace) 966 { 967 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 968 "/** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */", 969 op[0], op[1], op[2], op[3]); 970 printf (" mx = 0x%x,", mx); 971 printf (" ss = 0x%x,", ss); 972 printf (" rsrc = 0x%x,", rsrc); 973 printf (" rdst = 0x%x\n", rdst); 974 } 975 SYNTAX("div %1%S1, %0"); 976 #line 692 "rx-decode.opc" 977 ID(div); SPm(ss, rsrc, mx); DR(rdst); F_O___; 978 979 /*----------------------------------------------------------------------*/ 980 /* DIVU */ 981 982 } 983 break; 984 } 985 break; 986 case 0x09: 987 GETBYTE (); 988 switch (op[3] & 0x00) 989 { 990 case 0x00: 991 op_semantics_13: 992 { 993 /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */ 994 #line 704 "rx-decode.opc" 995 int mx AU = (op[1] >> 6) & 0x03; 996 #line 704 "rx-decode.opc" 997 int ss AU = op[1] & 0x03; 998 #line 704 "rx-decode.opc" 999 int rsrc AU = (op[3] >> 4) & 0x0f; 1000 #line 704 "rx-decode.opc" 1001 int rdst AU = op[3] & 0x0f; 1002 if (trace) 1003 { 1004 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 1005 "/** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */", 1006 op[0], op[1], op[2], op[3]); 1007 printf (" mx = 0x%x,", mx); 1008 printf (" ss = 0x%x,", ss); 1009 printf (" rsrc = 0x%x,", rsrc); 1010 printf (" rdst = 0x%x\n", rdst); 1011 } 1012 SYNTAX("divu %1%S1, %0"); 1013 #line 704 "rx-decode.opc" 1014 ID(divu); SPm(ss, rsrc, mx); DR(rdst); F_O___; 1015 1016 /*----------------------------------------------------------------------*/ 1017 /* SHIFT */ 1018 1019 } 1020 break; 1021 } 1022 break; 1023 case 0x0c: 1024 GETBYTE (); 1025 switch (op[3] & 0x00) 1026 { 1027 case 0x00: 1028 op_semantics_14: 1029 { 1030 /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */ 1031 #line 477 "rx-decode.opc" 1032 int mx AU = (op[1] >> 6) & 0x03; 1033 #line 477 "rx-decode.opc" 1034 int ss AU = op[1] & 0x03; 1035 #line 477 "rx-decode.opc" 1036 int rsrc AU = (op[3] >> 4) & 0x0f; 1037 #line 477 "rx-decode.opc" 1038 int rdst AU = op[3] & 0x0f; 1039 if (trace) 1040 { 1041 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 1042 "/** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */", 1043 op[0], op[1], op[2], op[3]); 1044 printf (" mx = 0x%x,", mx); 1045 printf (" ss = 0x%x,", ss); 1046 printf (" rsrc = 0x%x,", rsrc); 1047 printf (" rdst = 0x%x\n", rdst); 1048 } 1049 SYNTAX("tst %1%S1, %2"); 1050 #line 477 "rx-decode.opc" 1051 ID(and); SPm(ss, rsrc, mx); S2R(rdst); F__SZ_; 1052 1053 /*----------------------------------------------------------------------*/ 1054 /* NEG */ 1055 1056 } 1057 break; 1058 } 1059 break; 1060 case 0x0d: 1061 GETBYTE (); 1062 switch (op[3] & 0x00) 1063 { 1064 case 0x00: 1065 op_semantics_15: 1066 { 1067 /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */ 1068 #line 456 "rx-decode.opc" 1069 int mx AU = (op[1] >> 6) & 0x03; 1070 #line 456 "rx-decode.opc" 1071 int ss AU = op[1] & 0x03; 1072 #line 456 "rx-decode.opc" 1073 int rsrc AU = (op[3] >> 4) & 0x0f; 1074 #line 456 "rx-decode.opc" 1075 int rdst AU = op[3] & 0x0f; 1076 if (trace) 1077 { 1078 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 1079 "/** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */", 1080 op[0], op[1], op[2], op[3]); 1081 printf (" mx = 0x%x,", mx); 1082 printf (" ss = 0x%x,", ss); 1083 printf (" rsrc = 0x%x,", rsrc); 1084 printf (" rdst = 0x%x\n", rdst); 1085 } 1086 SYNTAX("xor %1%S1, %0"); 1087 #line 456 "rx-decode.opc" 1088 ID(xor); SPm(ss, rsrc, mx); DR(rdst); F__SZ_; 1089 1090 /*----------------------------------------------------------------------*/ 1091 /* NOT */ 1092 1093 } 1094 break; 1095 } 1096 break; 1097 case 0x10: 1098 GETBYTE (); 1099 switch (op[3] & 0x00) 1100 { 1101 case 0x00: 1102 op_semantics_16: 1103 { 1104 /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */ 1105 #line 390 "rx-decode.opc" 1106 int mx AU = (op[1] >> 6) & 0x03; 1107 #line 390 "rx-decode.opc" 1108 int ss AU = op[1] & 0x03; 1109 #line 390 "rx-decode.opc" 1110 int rsrc AU = (op[3] >> 4) & 0x0f; 1111 #line 390 "rx-decode.opc" 1112 int rdst AU = op[3] & 0x0f; 1113 if (trace) 1114 { 1115 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 1116 "/** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */", 1117 op[0], op[1], op[2], op[3]); 1118 printf (" mx = 0x%x,", mx); 1119 printf (" ss = 0x%x,", ss); 1120 printf (" rsrc = 0x%x,", rsrc); 1121 printf (" rdst = 0x%x\n", rdst); 1122 } 1123 SYNTAX("xchg %1%S1, %0"); 1124 #line 390 "rx-decode.opc" 1125 ID(xchg); DR(rdst); SPm(ss, rsrc, mx); 1126 1127 /*----------------------------------------------------------------------*/ 1128 /* STZ/STNZ */ 1129 1130 } 1131 break; 1132 } 1133 break; 1134 case 0x11: 1135 GETBYTE (); 1136 switch (op[3] & 0x00) 1137 { 1138 case 0x00: 1139 op_semantics_17: 1140 { 1141 /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */ 1142 #line 933 "rx-decode.opc" 1143 int mx AU = (op[1] >> 6) & 0x03; 1144 #line 933 "rx-decode.opc" 1145 int sd AU = op[1] & 0x03; 1146 #line 933 "rx-decode.opc" 1147 int rsrc AU = (op[3] >> 4) & 0x0f; 1148 #line 933 "rx-decode.opc" 1149 int rdst AU = op[3] & 0x0f; 1150 if (trace) 1151 { 1152 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 1153 "/** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */", 1154 op[0], op[1], op[2], op[3]); 1155 printf (" mx = 0x%x,", mx); 1156 printf (" sd = 0x%x,", sd); 1157 printf (" rsrc = 0x%x,", rsrc); 1158 printf (" rdst = 0x%x\n", rdst); 1159 } 1160 SYNTAX("itof %1%S1, %0"); 1161 #line 933 "rx-decode.opc" 1162 ID(itof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_; 1163 1164 /*----------------------------------------------------------------------*/ 1165 /* BIT OPS */ 1166 1167 } 1168 break; 1169 } 1170 break; 1171 case 0x15: 1172 GETBYTE (); 1173 switch (op[3] & 0x00) 1174 { 1175 case 0x00: 1176 op_semantics_18: 1177 { 1178 /** 0000 0110 mx10 00sd 0001 0101 rsrc rdst utof %1%S1, %0 */ 1179 #line 1119 "rx-decode.opc" 1180 int mx AU = (op[1] >> 6) & 0x03; 1181 #line 1119 "rx-decode.opc" 1182 int sd AU = op[1] & 0x03; 1183 #line 1119 "rx-decode.opc" 1184 int rsrc AU = (op[3] >> 4) & 0x0f; 1185 #line 1119 "rx-decode.opc" 1186 int rdst AU = op[3] & 0x0f; 1187 if (trace) 1188 { 1189 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 1190 "/** 0000 0110 mx10 00sd 0001 0101 rsrc rdst utof %1%S1, %0 */", 1191 op[0], op[1], op[2], op[3]); 1192 printf (" mx = 0x%x,", mx); 1193 printf (" sd = 0x%x,", sd); 1194 printf (" rsrc = 0x%x,", rsrc); 1195 printf (" rdst = 0x%x\n", rdst); 1196 } 1197 SYNTAX("utof %1%S1, %0"); 1198 #line 1119 "rx-decode.opc" 1199 ID(utof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_; 1200 1201 } 1202 break; 1203 } 1204 break; 1205 default: UNSUPPORTED(); break; 1206 } 1207 break; 1208 case 0x21: 1209 GETBYTE (); 1210 switch (op[2] & 0xff) 1211 { 1212 case 0x00: 1213 GETBYTE (); 1214 switch (op[3] & 0x00) 1215 { 1216 case 0x00: 1217 goto op_semantics_7; 1218 break; 1219 } 1220 break; 1221 case 0x04: 1222 GETBYTE (); 1223 switch (op[3] & 0x00) 1224 { 1225 case 0x00: 1226 goto op_semantics_8; 1227 break; 1228 } 1229 break; 1230 case 0x05: 1231 GETBYTE (); 1232 switch (op[3] & 0x00) 1233 { 1234 case 0x00: 1235 goto op_semantics_9; 1236 break; 1237 } 1238 break; 1239 case 0x06: 1240 GETBYTE (); 1241 switch (op[3] & 0x00) 1242 { 1243 case 0x00: 1244 goto op_semantics_10; 1245 break; 1246 } 1247 break; 1248 case 0x07: 1249 GETBYTE (); 1250 switch (op[3] & 0x00) 1251 { 1252 case 0x00: 1253 goto op_semantics_11; 1254 break; 1255 } 1256 break; 1257 case 0x08: 1258 GETBYTE (); 1259 switch (op[3] & 0x00) 1260 { 1261 case 0x00: 1262 goto op_semantics_12; 1263 break; 1264 } 1265 break; 1266 case 0x09: 1267 GETBYTE (); 1268 switch (op[3] & 0x00) 1269 { 1270 case 0x00: 1271 goto op_semantics_13; 1272 break; 1273 } 1274 break; 1275 case 0x0c: 1276 GETBYTE (); 1277 switch (op[3] & 0x00) 1278 { 1279 case 0x00: 1280 goto op_semantics_14; 1281 break; 1282 } 1283 break; 1284 case 0x0d: 1285 GETBYTE (); 1286 switch (op[3] & 0x00) 1287 { 1288 case 0x00: 1289 goto op_semantics_15; 1290 break; 1291 } 1292 break; 1293 case 0x10: 1294 GETBYTE (); 1295 switch (op[3] & 0x00) 1296 { 1297 case 0x00: 1298 goto op_semantics_16; 1299 break; 1300 } 1301 break; 1302 case 0x11: 1303 GETBYTE (); 1304 switch (op[3] & 0x00) 1305 { 1306 case 0x00: 1307 goto op_semantics_17; 1308 break; 1309 } 1310 break; 1311 case 0x15: 1312 GETBYTE (); 1313 switch (op[3] & 0x00) 1314 { 1315 case 0x00: 1316 goto op_semantics_18; 1317 break; 1318 } 1319 break; 1320 default: UNSUPPORTED(); break; 1321 } 1322 break; 1323 case 0x22: 1324 GETBYTE (); 1325 switch (op[2] & 0xff) 1326 { 1327 case 0x00: 1328 GETBYTE (); 1329 switch (op[3] & 0x00) 1330 { 1331 case 0x00: 1332 goto op_semantics_7; 1333 break; 1334 } 1335 break; 1336 case 0x04: 1337 GETBYTE (); 1338 switch (op[3] & 0x00) 1339 { 1340 case 0x00: 1341 goto op_semantics_8; 1342 break; 1343 } 1344 break; 1345 case 0x05: 1346 GETBYTE (); 1347 switch (op[3] & 0x00) 1348 { 1349 case 0x00: 1350 goto op_semantics_9; 1351 break; 1352 } 1353 break; 1354 case 0x06: 1355 GETBYTE (); 1356 switch (op[3] & 0x00) 1357 { 1358 case 0x00: 1359 goto op_semantics_10; 1360 break; 1361 } 1362 break; 1363 case 0x07: 1364 GETBYTE (); 1365 switch (op[3] & 0x00) 1366 { 1367 case 0x00: 1368 goto op_semantics_11; 1369 break; 1370 } 1371 break; 1372 case 0x08: 1373 GETBYTE (); 1374 switch (op[3] & 0x00) 1375 { 1376 case 0x00: 1377 goto op_semantics_12; 1378 break; 1379 } 1380 break; 1381 case 0x09: 1382 GETBYTE (); 1383 switch (op[3] & 0x00) 1384 { 1385 case 0x00: 1386 goto op_semantics_13; 1387 break; 1388 } 1389 break; 1390 case 0x0c: 1391 GETBYTE (); 1392 switch (op[3] & 0x00) 1393 { 1394 case 0x00: 1395 goto op_semantics_14; 1396 break; 1397 } 1398 break; 1399 case 0x0d: 1400 GETBYTE (); 1401 switch (op[3] & 0x00) 1402 { 1403 case 0x00: 1404 goto op_semantics_15; 1405 break; 1406 } 1407 break; 1408 case 0x10: 1409 GETBYTE (); 1410 switch (op[3] & 0x00) 1411 { 1412 case 0x00: 1413 goto op_semantics_16; 1414 break; 1415 } 1416 break; 1417 case 0x11: 1418 GETBYTE (); 1419 switch (op[3] & 0x00) 1420 { 1421 case 0x00: 1422 goto op_semantics_17; 1423 break; 1424 } 1425 break; 1426 case 0x15: 1427 GETBYTE (); 1428 switch (op[3] & 0x00) 1429 { 1430 case 0x00: 1431 goto op_semantics_18; 1432 break; 1433 } 1434 break; 1435 default: UNSUPPORTED(); break; 1436 } 1437 break; 1438 case 0x23: 1439 GETBYTE (); 1440 switch (op[2] & 0xff) 1441 { 1442 case 0x00: 1443 GETBYTE (); 1444 switch (op[3] & 0x00) 1445 { 1446 case 0x00: 1447 goto op_semantics_7; 1448 break; 1449 } 1450 break; 1451 case 0x04: 1452 GETBYTE (); 1453 switch (op[3] & 0x00) 1454 { 1455 case 0x00: 1456 goto op_semantics_8; 1457 break; 1458 } 1459 break; 1460 case 0x05: 1461 GETBYTE (); 1462 switch (op[3] & 0x00) 1463 { 1464 case 0x00: 1465 goto op_semantics_9; 1466 break; 1467 } 1468 break; 1469 case 0x06: 1470 GETBYTE (); 1471 switch (op[3] & 0x00) 1472 { 1473 case 0x00: 1474 goto op_semantics_10; 1475 break; 1476 } 1477 break; 1478 case 0x07: 1479 GETBYTE (); 1480 switch (op[3] & 0x00) 1481 { 1482 case 0x00: 1483 goto op_semantics_11; 1484 break; 1485 } 1486 break; 1487 case 0x08: 1488 GETBYTE (); 1489 switch (op[3] & 0x00) 1490 { 1491 case 0x00: 1492 goto op_semantics_12; 1493 break; 1494 } 1495 break; 1496 case 0x09: 1497 GETBYTE (); 1498 switch (op[3] & 0x00) 1499 { 1500 case 0x00: 1501 goto op_semantics_13; 1502 break; 1503 } 1504 break; 1505 case 0x0c: 1506 GETBYTE (); 1507 switch (op[3] & 0x00) 1508 { 1509 case 0x00: 1510 goto op_semantics_14; 1511 break; 1512 } 1513 break; 1514 case 0x0d: 1515 GETBYTE (); 1516 switch (op[3] & 0x00) 1517 { 1518 case 0x00: 1519 goto op_semantics_15; 1520 break; 1521 } 1522 break; 1523 case 0x10: 1524 GETBYTE (); 1525 switch (op[3] & 0x00) 1526 { 1527 case 0x00: 1528 goto op_semantics_16; 1529 break; 1530 } 1531 break; 1532 case 0x11: 1533 GETBYTE (); 1534 switch (op[3] & 0x00) 1535 { 1536 case 0x00: 1537 goto op_semantics_17; 1538 break; 1539 } 1540 break; 1541 case 0x15: 1542 GETBYTE (); 1543 switch (op[3] & 0x00) 1544 { 1545 case 0x00: 1546 goto op_semantics_18; 1547 break; 1548 } 1549 break; 1550 default: UNSUPPORTED(); break; 1551 } 1552 break; 1553 case 0x40: 1554 GETBYTE (); 1555 switch (op[2] & 0x00) 1556 { 1557 case 0x00: 1558 goto op_semantics_1; 1559 break; 1560 } 1561 break; 1562 case 0x41: 1563 GETBYTE (); 1564 switch (op[2] & 0x00) 1565 { 1566 case 0x00: 1567 goto op_semantics_1; 1568 break; 1569 } 1570 break; 1571 case 0x42: 1572 GETBYTE (); 1573 switch (op[2] & 0x00) 1574 { 1575 case 0x00: 1576 goto op_semantics_1; 1577 break; 1578 } 1579 break; 1580 case 0x43: 1581 GETBYTE (); 1582 switch (op[2] & 0x00) 1583 { 1584 case 0x00: 1585 goto op_semantics_1; 1586 break; 1587 } 1588 break; 1589 case 0x44: 1590 GETBYTE (); 1591 switch (op[2] & 0x00) 1592 { 1593 case 0x00: 1594 goto op_semantics_2; 1595 break; 1596 } 1597 break; 1598 case 0x45: 1599 GETBYTE (); 1600 switch (op[2] & 0x00) 1601 { 1602 case 0x00: 1603 goto op_semantics_2; 1604 break; 1605 } 1606 break; 1607 case 0x46: 1608 GETBYTE (); 1609 switch (op[2] & 0x00) 1610 { 1611 case 0x00: 1612 goto op_semantics_2; 1613 break; 1614 } 1615 break; 1616 case 0x47: 1617 GETBYTE (); 1618 switch (op[2] & 0x00) 1619 { 1620 case 0x00: 1621 goto op_semantics_2; 1622 break; 1623 } 1624 break; 1625 case 0x48: 1626 GETBYTE (); 1627 switch (op[2] & 0x00) 1628 { 1629 case 0x00: 1630 goto op_semantics_3; 1631 break; 1632 } 1633 break; 1634 case 0x49: 1635 GETBYTE (); 1636 switch (op[2] & 0x00) 1637 { 1638 case 0x00: 1639 goto op_semantics_3; 1640 break; 1641 } 1642 break; 1643 case 0x4a: 1644 GETBYTE (); 1645 switch (op[2] & 0x00) 1646 { 1647 case 0x00: 1648 goto op_semantics_3; 1649 break; 1650 } 1651 break; 1652 case 0x4b: 1653 GETBYTE (); 1654 switch (op[2] & 0x00) 1655 { 1656 case 0x00: 1657 goto op_semantics_3; 1658 break; 1659 } 1660 break; 1661 case 0x4c: 1662 GETBYTE (); 1663 switch (op[2] & 0x00) 1664 { 1665 case 0x00: 1666 goto op_semantics_4; 1667 break; 1668 } 1669 break; 1670 case 0x4d: 1671 GETBYTE (); 1672 switch (op[2] & 0x00) 1673 { 1674 case 0x00: 1675 goto op_semantics_4; 1676 break; 1677 } 1678 break; 1679 case 0x4e: 1680 GETBYTE (); 1681 switch (op[2] & 0x00) 1682 { 1683 case 0x00: 1684 goto op_semantics_4; 1685 break; 1686 } 1687 break; 1688 case 0x4f: 1689 GETBYTE (); 1690 switch (op[2] & 0x00) 1691 { 1692 case 0x00: 1693 goto op_semantics_4; 1694 break; 1695 } 1696 break; 1697 case 0x50: 1698 GETBYTE (); 1699 switch (op[2] & 0x00) 1700 { 1701 case 0x00: 1702 goto op_semantics_5; 1703 break; 1704 } 1705 break; 1706 case 0x51: 1707 GETBYTE (); 1708 switch (op[2] & 0x00) 1709 { 1710 case 0x00: 1711 goto op_semantics_5; 1712 break; 1713 } 1714 break; 1715 case 0x52: 1716 GETBYTE (); 1717 switch (op[2] & 0x00) 1718 { 1719 case 0x00: 1720 goto op_semantics_5; 1721 break; 1722 } 1723 break; 1724 case 0x53: 1725 GETBYTE (); 1726 switch (op[2] & 0x00) 1727 { 1728 case 0x00: 1729 goto op_semantics_5; 1730 break; 1731 } 1732 break; 1733 case 0x54: 1734 GETBYTE (); 1735 switch (op[2] & 0x00) 1736 { 1737 case 0x00: 1738 goto op_semantics_6; 1739 break; 1740 } 1741 break; 1742 case 0x55: 1743 GETBYTE (); 1744 switch (op[2] & 0x00) 1745 { 1746 case 0x00: 1747 goto op_semantics_6; 1748 break; 1749 } 1750 break; 1751 case 0x56: 1752 GETBYTE (); 1753 switch (op[2] & 0x00) 1754 { 1755 case 0x00: 1756 goto op_semantics_6; 1757 break; 1758 } 1759 break; 1760 case 0x57: 1761 GETBYTE (); 1762 switch (op[2] & 0x00) 1763 { 1764 case 0x00: 1765 goto op_semantics_6; 1766 break; 1767 } 1768 break; 1769 case 0x60: 1770 GETBYTE (); 1771 switch (op[2] & 0xff) 1772 { 1773 case 0x00: 1774 GETBYTE (); 1775 switch (op[3] & 0x00) 1776 { 1777 case 0x00: 1778 goto op_semantics_7; 1779 break; 1780 } 1781 break; 1782 case 0x04: 1783 GETBYTE (); 1784 switch (op[3] & 0x00) 1785 { 1786 case 0x00: 1787 goto op_semantics_8; 1788 break; 1789 } 1790 break; 1791 case 0x05: 1792 GETBYTE (); 1793 switch (op[3] & 0x00) 1794 { 1795 case 0x00: 1796 goto op_semantics_9; 1797 break; 1798 } 1799 break; 1800 case 0x06: 1801 GETBYTE (); 1802 switch (op[3] & 0x00) 1803 { 1804 case 0x00: 1805 goto op_semantics_10; 1806 break; 1807 } 1808 break; 1809 case 0x07: 1810 GETBYTE (); 1811 switch (op[3] & 0x00) 1812 { 1813 case 0x00: 1814 goto op_semantics_11; 1815 break; 1816 } 1817 break; 1818 case 0x08: 1819 GETBYTE (); 1820 switch (op[3] & 0x00) 1821 { 1822 case 0x00: 1823 goto op_semantics_12; 1824 break; 1825 } 1826 break; 1827 case 0x09: 1828 GETBYTE (); 1829 switch (op[3] & 0x00) 1830 { 1831 case 0x00: 1832 goto op_semantics_13; 1833 break; 1834 } 1835 break; 1836 case 0x0c: 1837 GETBYTE (); 1838 switch (op[3] & 0x00) 1839 { 1840 case 0x00: 1841 goto op_semantics_14; 1842 break; 1843 } 1844 break; 1845 case 0x0d: 1846 GETBYTE (); 1847 switch (op[3] & 0x00) 1848 { 1849 case 0x00: 1850 goto op_semantics_15; 1851 break; 1852 } 1853 break; 1854 case 0x10: 1855 GETBYTE (); 1856 switch (op[3] & 0x00) 1857 { 1858 case 0x00: 1859 goto op_semantics_16; 1860 break; 1861 } 1862 break; 1863 case 0x11: 1864 GETBYTE (); 1865 switch (op[3] & 0x00) 1866 { 1867 case 0x00: 1868 goto op_semantics_17; 1869 break; 1870 } 1871 break; 1872 case 0x15: 1873 GETBYTE (); 1874 switch (op[3] & 0x00) 1875 { 1876 case 0x00: 1877 goto op_semantics_18; 1878 break; 1879 } 1880 break; 1881 default: UNSUPPORTED(); break; 1882 } 1883 break; 1884 case 0x61: 1885 GETBYTE (); 1886 switch (op[2] & 0xff) 1887 { 1888 case 0x00: 1889 GETBYTE (); 1890 switch (op[3] & 0x00) 1891 { 1892 case 0x00: 1893 goto op_semantics_7; 1894 break; 1895 } 1896 break; 1897 case 0x04: 1898 GETBYTE (); 1899 switch (op[3] & 0x00) 1900 { 1901 case 0x00: 1902 goto op_semantics_8; 1903 break; 1904 } 1905 break; 1906 case 0x05: 1907 GETBYTE (); 1908 switch (op[3] & 0x00) 1909 { 1910 case 0x00: 1911 goto op_semantics_9; 1912 break; 1913 } 1914 break; 1915 case 0x06: 1916 GETBYTE (); 1917 switch (op[3] & 0x00) 1918 { 1919 case 0x00: 1920 goto op_semantics_10; 1921 break; 1922 } 1923 break; 1924 case 0x07: 1925 GETBYTE (); 1926 switch (op[3] & 0x00) 1927 { 1928 case 0x00: 1929 goto op_semantics_11; 1930 break; 1931 } 1932 break; 1933 case 0x08: 1934 GETBYTE (); 1935 switch (op[3] & 0x00) 1936 { 1937 case 0x00: 1938 goto op_semantics_12; 1939 break; 1940 } 1941 break; 1942 case 0x09: 1943 GETBYTE (); 1944 switch (op[3] & 0x00) 1945 { 1946 case 0x00: 1947 goto op_semantics_13; 1948 break; 1949 } 1950 break; 1951 case 0x0c: 1952 GETBYTE (); 1953 switch (op[3] & 0x00) 1954 { 1955 case 0x00: 1956 goto op_semantics_14; 1957 break; 1958 } 1959 break; 1960 case 0x0d: 1961 GETBYTE (); 1962 switch (op[3] & 0x00) 1963 { 1964 case 0x00: 1965 goto op_semantics_15; 1966 break; 1967 } 1968 break; 1969 case 0x10: 1970 GETBYTE (); 1971 switch (op[3] & 0x00) 1972 { 1973 case 0x00: 1974 goto op_semantics_16; 1975 break; 1976 } 1977 break; 1978 case 0x11: 1979 GETBYTE (); 1980 switch (op[3] & 0x00) 1981 { 1982 case 0x00: 1983 goto op_semantics_17; 1984 break; 1985 } 1986 break; 1987 case 0x15: 1988 GETBYTE (); 1989 switch (op[3] & 0x00) 1990 { 1991 case 0x00: 1992 goto op_semantics_18; 1993 break; 1994 } 1995 break; 1996 default: UNSUPPORTED(); break; 1997 } 1998 break; 1999 case 0x62: 2000 GETBYTE (); 2001 switch (op[2] & 0xff) 2002 { 2003 case 0x00: 2004 GETBYTE (); 2005 switch (op[3] & 0x00) 2006 { 2007 case 0x00: 2008 goto op_semantics_7; 2009 break; 2010 } 2011 break; 2012 case 0x04: 2013 GETBYTE (); 2014 switch (op[3] & 0x00) 2015 { 2016 case 0x00: 2017 goto op_semantics_8; 2018 break; 2019 } 2020 break; 2021 case 0x05: 2022 GETBYTE (); 2023 switch (op[3] & 0x00) 2024 { 2025 case 0x00: 2026 goto op_semantics_9; 2027 break; 2028 } 2029 break; 2030 case 0x06: 2031 GETBYTE (); 2032 switch (op[3] & 0x00) 2033 { 2034 case 0x00: 2035 goto op_semantics_10; 2036 break; 2037 } 2038 break; 2039 case 0x07: 2040 GETBYTE (); 2041 switch (op[3] & 0x00) 2042 { 2043 case 0x00: 2044 goto op_semantics_11; 2045 break; 2046 } 2047 break; 2048 case 0x08: 2049 GETBYTE (); 2050 switch (op[3] & 0x00) 2051 { 2052 case 0x00: 2053 goto op_semantics_12; 2054 break; 2055 } 2056 break; 2057 case 0x09: 2058 GETBYTE (); 2059 switch (op[3] & 0x00) 2060 { 2061 case 0x00: 2062 goto op_semantics_13; 2063 break; 2064 } 2065 break; 2066 case 0x0c: 2067 GETBYTE (); 2068 switch (op[3] & 0x00) 2069 { 2070 case 0x00: 2071 goto op_semantics_14; 2072 break; 2073 } 2074 break; 2075 case 0x0d: 2076 GETBYTE (); 2077 switch (op[3] & 0x00) 2078 { 2079 case 0x00: 2080 goto op_semantics_15; 2081 break; 2082 } 2083 break; 2084 case 0x10: 2085 GETBYTE (); 2086 switch (op[3] & 0x00) 2087 { 2088 case 0x00: 2089 goto op_semantics_16; 2090 break; 2091 } 2092 break; 2093 case 0x11: 2094 GETBYTE (); 2095 switch (op[3] & 0x00) 2096 { 2097 case 0x00: 2098 goto op_semantics_17; 2099 break; 2100 } 2101 break; 2102 case 0x15: 2103 GETBYTE (); 2104 switch (op[3] & 0x00) 2105 { 2106 case 0x00: 2107 goto op_semantics_18; 2108 break; 2109 } 2110 break; 2111 default: UNSUPPORTED(); break; 2112 } 2113 break; 2114 case 0x63: 2115 GETBYTE (); 2116 switch (op[2] & 0xff) 2117 { 2118 case 0x00: 2119 GETBYTE (); 2120 switch (op[3] & 0x00) 2121 { 2122 case 0x00: 2123 goto op_semantics_7; 2124 break; 2125 } 2126 break; 2127 case 0x04: 2128 GETBYTE (); 2129 switch (op[3] & 0x00) 2130 { 2131 case 0x00: 2132 goto op_semantics_8; 2133 break; 2134 } 2135 break; 2136 case 0x05: 2137 GETBYTE (); 2138 switch (op[3] & 0x00) 2139 { 2140 case 0x00: 2141 goto op_semantics_9; 2142 break; 2143 } 2144 break; 2145 case 0x06: 2146 GETBYTE (); 2147 switch (op[3] & 0x00) 2148 { 2149 case 0x00: 2150 goto op_semantics_10; 2151 break; 2152 } 2153 break; 2154 case 0x07: 2155 GETBYTE (); 2156 switch (op[3] & 0x00) 2157 { 2158 case 0x00: 2159 goto op_semantics_11; 2160 break; 2161 } 2162 break; 2163 case 0x08: 2164 GETBYTE (); 2165 switch (op[3] & 0x00) 2166 { 2167 case 0x00: 2168 goto op_semantics_12; 2169 break; 2170 } 2171 break; 2172 case 0x09: 2173 GETBYTE (); 2174 switch (op[3] & 0x00) 2175 { 2176 case 0x00: 2177 goto op_semantics_13; 2178 break; 2179 } 2180 break; 2181 case 0x0c: 2182 GETBYTE (); 2183 switch (op[3] & 0x00) 2184 { 2185 case 0x00: 2186 goto op_semantics_14; 2187 break; 2188 } 2189 break; 2190 case 0x0d: 2191 GETBYTE (); 2192 switch (op[3] & 0x00) 2193 { 2194 case 0x00: 2195 goto op_semantics_15; 2196 break; 2197 } 2198 break; 2199 case 0x10: 2200 GETBYTE (); 2201 switch (op[3] & 0x00) 2202 { 2203 case 0x00: 2204 goto op_semantics_16; 2205 break; 2206 } 2207 break; 2208 case 0x11: 2209 GETBYTE (); 2210 switch (op[3] & 0x00) 2211 { 2212 case 0x00: 2213 goto op_semantics_17; 2214 break; 2215 } 2216 break; 2217 case 0x15: 2218 GETBYTE (); 2219 switch (op[3] & 0x00) 2220 { 2221 case 0x00: 2222 goto op_semantics_18; 2223 break; 2224 } 2225 break; 2226 default: UNSUPPORTED(); break; 2227 } 2228 break; 2229 case 0x80: 2230 GETBYTE (); 2231 switch (op[2] & 0x00) 2232 { 2233 case 0x00: 2234 goto op_semantics_1; 2235 break; 2236 } 2237 break; 2238 case 0x81: 2239 GETBYTE (); 2240 switch (op[2] & 0x00) 2241 { 2242 case 0x00: 2243 goto op_semantics_1; 2244 break; 2245 } 2246 break; 2247 case 0x82: 2248 GETBYTE (); 2249 switch (op[2] & 0x00) 2250 { 2251 case 0x00: 2252 goto op_semantics_1; 2253 break; 2254 } 2255 break; 2256 case 0x83: 2257 GETBYTE (); 2258 switch (op[2] & 0x00) 2259 { 2260 case 0x00: 2261 goto op_semantics_1; 2262 break; 2263 } 2264 break; 2265 case 0x84: 2266 GETBYTE (); 2267 switch (op[2] & 0x00) 2268 { 2269 case 0x00: 2270 goto op_semantics_2; 2271 break; 2272 } 2273 break; 2274 case 0x85: 2275 GETBYTE (); 2276 switch (op[2] & 0x00) 2277 { 2278 case 0x00: 2279 goto op_semantics_2; 2280 break; 2281 } 2282 break; 2283 case 0x86: 2284 GETBYTE (); 2285 switch (op[2] & 0x00) 2286 { 2287 case 0x00: 2288 goto op_semantics_2; 2289 break; 2290 } 2291 break; 2292 case 0x87: 2293 GETBYTE (); 2294 switch (op[2] & 0x00) 2295 { 2296 case 0x00: 2297 goto op_semantics_2; 2298 break; 2299 } 2300 break; 2301 case 0x88: 2302 GETBYTE (); 2303 switch (op[2] & 0x00) 2304 { 2305 case 0x00: 2306 goto op_semantics_3; 2307 break; 2308 } 2309 break; 2310 case 0x89: 2311 GETBYTE (); 2312 switch (op[2] & 0x00) 2313 { 2314 case 0x00: 2315 goto op_semantics_3; 2316 break; 2317 } 2318 break; 2319 case 0x8a: 2320 GETBYTE (); 2321 switch (op[2] & 0x00) 2322 { 2323 case 0x00: 2324 goto op_semantics_3; 2325 break; 2326 } 2327 break; 2328 case 0x8b: 2329 GETBYTE (); 2330 switch (op[2] & 0x00) 2331 { 2332 case 0x00: 2333 goto op_semantics_3; 2334 break; 2335 } 2336 break; 2337 case 0x8c: 2338 GETBYTE (); 2339 switch (op[2] & 0x00) 2340 { 2341 case 0x00: 2342 goto op_semantics_4; 2343 break; 2344 } 2345 break; 2346 case 0x8d: 2347 GETBYTE (); 2348 switch (op[2] & 0x00) 2349 { 2350 case 0x00: 2351 goto op_semantics_4; 2352 break; 2353 } 2354 break; 2355 case 0x8e: 2356 GETBYTE (); 2357 switch (op[2] & 0x00) 2358 { 2359 case 0x00: 2360 goto op_semantics_4; 2361 break; 2362 } 2363 break; 2364 case 0x8f: 2365 GETBYTE (); 2366 switch (op[2] & 0x00) 2367 { 2368 case 0x00: 2369 goto op_semantics_4; 2370 break; 2371 } 2372 break; 2373 case 0x90: 2374 GETBYTE (); 2375 switch (op[2] & 0x00) 2376 { 2377 case 0x00: 2378 goto op_semantics_5; 2379 break; 2380 } 2381 break; 2382 case 0x91: 2383 GETBYTE (); 2384 switch (op[2] & 0x00) 2385 { 2386 case 0x00: 2387 goto op_semantics_5; 2388 break; 2389 } 2390 break; 2391 case 0x92: 2392 GETBYTE (); 2393 switch (op[2] & 0x00) 2394 { 2395 case 0x00: 2396 goto op_semantics_5; 2397 break; 2398 } 2399 break; 2400 case 0x93: 2401 GETBYTE (); 2402 switch (op[2] & 0x00) 2403 { 2404 case 0x00: 2405 goto op_semantics_5; 2406 break; 2407 } 2408 break; 2409 case 0x94: 2410 GETBYTE (); 2411 switch (op[2] & 0x00) 2412 { 2413 case 0x00: 2414 goto op_semantics_6; 2415 break; 2416 } 2417 break; 2418 case 0x95: 2419 GETBYTE (); 2420 switch (op[2] & 0x00) 2421 { 2422 case 0x00: 2423 goto op_semantics_6; 2424 break; 2425 } 2426 break; 2427 case 0x96: 2428 GETBYTE (); 2429 switch (op[2] & 0x00) 2430 { 2431 case 0x00: 2432 goto op_semantics_6; 2433 break; 2434 } 2435 break; 2436 case 0x97: 2437 GETBYTE (); 2438 switch (op[2] & 0x00) 2439 { 2440 case 0x00: 2441 goto op_semantics_6; 2442 break; 2443 } 2444 break; 2445 case 0xa0: 2446 GETBYTE (); 2447 switch (op[2] & 0xff) 2448 { 2449 case 0x00: 2450 GETBYTE (); 2451 switch (op[3] & 0x00) 2452 { 2453 case 0x00: 2454 goto op_semantics_7; 2455 break; 2456 } 2457 break; 2458 case 0x02: 2459 GETBYTE (); 2460 switch (op[3] & 0x00) 2461 { 2462 case 0x00: 2463 op_semantics_19: 2464 { 2465 /** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */ 2466 #line 498 "rx-decode.opc" 2467 int ss AU = op[1] & 0x03; 2468 #line 498 "rx-decode.opc" 2469 int rsrc AU = (op[3] >> 4) & 0x0f; 2470 #line 498 "rx-decode.opc" 2471 int rdst AU = op[3] & 0x0f; 2472 if (trace) 2473 { 2474 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 2475 "/** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */", 2476 op[0], op[1], op[2], op[3]); 2477 printf (" ss = 0x%x,", ss); 2478 printf (" rsrc = 0x%x,", rsrc); 2479 printf (" rdst = 0x%x\n", rdst); 2480 } 2481 SYNTAX("adc %1%S1, %0"); 2482 #line 498 "rx-decode.opc" 2483 ID(adc); SPm(ss, rsrc, 2); DR(rdst); F_OSZC; 2484 2485 /*----------------------------------------------------------------------*/ 2486 /* ADD */ 2487 2488 } 2489 break; 2490 } 2491 break; 2492 case 0x04: 2493 GETBYTE (); 2494 switch (op[3] & 0x00) 2495 { 2496 case 0x00: 2497 goto op_semantics_8; 2498 break; 2499 } 2500 break; 2501 case 0x05: 2502 GETBYTE (); 2503 switch (op[3] & 0x00) 2504 { 2505 case 0x00: 2506 goto op_semantics_9; 2507 break; 2508 } 2509 break; 2510 case 0x06: 2511 GETBYTE (); 2512 switch (op[3] & 0x00) 2513 { 2514 case 0x00: 2515 goto op_semantics_10; 2516 break; 2517 } 2518 break; 2519 case 0x07: 2520 GETBYTE (); 2521 switch (op[3] & 0x00) 2522 { 2523 case 0x00: 2524 goto op_semantics_11; 2525 break; 2526 } 2527 break; 2528 case 0x08: 2529 GETBYTE (); 2530 switch (op[3] & 0x00) 2531 { 2532 case 0x00: 2533 goto op_semantics_12; 2534 break; 2535 } 2536 break; 2537 case 0x09: 2538 GETBYTE (); 2539 switch (op[3] & 0x00) 2540 { 2541 case 0x00: 2542 goto op_semantics_13; 2543 break; 2544 } 2545 break; 2546 case 0x0c: 2547 GETBYTE (); 2548 switch (op[3] & 0x00) 2549 { 2550 case 0x00: 2551 goto op_semantics_14; 2552 break; 2553 } 2554 break; 2555 case 0x0d: 2556 GETBYTE (); 2557 switch (op[3] & 0x00) 2558 { 2559 case 0x00: 2560 goto op_semantics_15; 2561 break; 2562 } 2563 break; 2564 case 0x10: 2565 GETBYTE (); 2566 switch (op[3] & 0x00) 2567 { 2568 case 0x00: 2569 goto op_semantics_16; 2570 break; 2571 } 2572 break; 2573 case 0x11: 2574 GETBYTE (); 2575 switch (op[3] & 0x00) 2576 { 2577 case 0x00: 2578 goto op_semantics_17; 2579 break; 2580 } 2581 break; 2582 case 0x15: 2583 GETBYTE (); 2584 switch (op[3] & 0x00) 2585 { 2586 case 0x00: 2587 goto op_semantics_18; 2588 break; 2589 } 2590 break; 2591 default: UNSUPPORTED(); break; 2592 } 2593 break; 2594 case 0xa1: 2595 GETBYTE (); 2596 switch (op[2] & 0xff) 2597 { 2598 case 0x00: 2599 GETBYTE (); 2600 switch (op[3] & 0x00) 2601 { 2602 case 0x00: 2603 goto op_semantics_7; 2604 break; 2605 } 2606 break; 2607 case 0x02: 2608 GETBYTE (); 2609 switch (op[3] & 0x00) 2610 { 2611 case 0x00: 2612 goto op_semantics_19; 2613 break; 2614 } 2615 break; 2616 case 0x04: 2617 GETBYTE (); 2618 switch (op[3] & 0x00) 2619 { 2620 case 0x00: 2621 goto op_semantics_8; 2622 break; 2623 } 2624 break; 2625 case 0x05: 2626 GETBYTE (); 2627 switch (op[3] & 0x00) 2628 { 2629 case 0x00: 2630 goto op_semantics_9; 2631 break; 2632 } 2633 break; 2634 case 0x06: 2635 GETBYTE (); 2636 switch (op[3] & 0x00) 2637 { 2638 case 0x00: 2639 goto op_semantics_10; 2640 break; 2641 } 2642 break; 2643 case 0x07: 2644 GETBYTE (); 2645 switch (op[3] & 0x00) 2646 { 2647 case 0x00: 2648 goto op_semantics_11; 2649 break; 2650 } 2651 break; 2652 case 0x08: 2653 GETBYTE (); 2654 switch (op[3] & 0x00) 2655 { 2656 case 0x00: 2657 goto op_semantics_12; 2658 break; 2659 } 2660 break; 2661 case 0x09: 2662 GETBYTE (); 2663 switch (op[3] & 0x00) 2664 { 2665 case 0x00: 2666 goto op_semantics_13; 2667 break; 2668 } 2669 break; 2670 case 0x0c: 2671 GETBYTE (); 2672 switch (op[3] & 0x00) 2673 { 2674 case 0x00: 2675 goto op_semantics_14; 2676 break; 2677 } 2678 break; 2679 case 0x0d: 2680 GETBYTE (); 2681 switch (op[3] & 0x00) 2682 { 2683 case 0x00: 2684 goto op_semantics_15; 2685 break; 2686 } 2687 break; 2688 case 0x10: 2689 GETBYTE (); 2690 switch (op[3] & 0x00) 2691 { 2692 case 0x00: 2693 goto op_semantics_16; 2694 break; 2695 } 2696 break; 2697 case 0x11: 2698 GETBYTE (); 2699 switch (op[3] & 0x00) 2700 { 2701 case 0x00: 2702 goto op_semantics_17; 2703 break; 2704 } 2705 break; 2706 case 0x15: 2707 GETBYTE (); 2708 switch (op[3] & 0x00) 2709 { 2710 case 0x00: 2711 goto op_semantics_18; 2712 break; 2713 } 2714 break; 2715 default: UNSUPPORTED(); break; 2716 } 2717 break; 2718 case 0xa2: 2719 GETBYTE (); 2720 switch (op[2] & 0xff) 2721 { 2722 case 0x00: 2723 GETBYTE (); 2724 switch (op[3] & 0x00) 2725 { 2726 case 0x00: 2727 goto op_semantics_7; 2728 break; 2729 } 2730 break; 2731 case 0x02: 2732 GETBYTE (); 2733 switch (op[3] & 0x00) 2734 { 2735 case 0x00: 2736 goto op_semantics_19; 2737 break; 2738 } 2739 break; 2740 case 0x04: 2741 GETBYTE (); 2742 switch (op[3] & 0x00) 2743 { 2744 case 0x00: 2745 goto op_semantics_8; 2746 break; 2747 } 2748 break; 2749 case 0x05: 2750 GETBYTE (); 2751 switch (op[3] & 0x00) 2752 { 2753 case 0x00: 2754 goto op_semantics_9; 2755 break; 2756 } 2757 break; 2758 case 0x06: 2759 GETBYTE (); 2760 switch (op[3] & 0x00) 2761 { 2762 case 0x00: 2763 goto op_semantics_10; 2764 break; 2765 } 2766 break; 2767 case 0x07: 2768 GETBYTE (); 2769 switch (op[3] & 0x00) 2770 { 2771 case 0x00: 2772 goto op_semantics_11; 2773 break; 2774 } 2775 break; 2776 case 0x08: 2777 GETBYTE (); 2778 switch (op[3] & 0x00) 2779 { 2780 case 0x00: 2781 goto op_semantics_12; 2782 break; 2783 } 2784 break; 2785 case 0x09: 2786 GETBYTE (); 2787 switch (op[3] & 0x00) 2788 { 2789 case 0x00: 2790 goto op_semantics_13; 2791 break; 2792 } 2793 break; 2794 case 0x0c: 2795 GETBYTE (); 2796 switch (op[3] & 0x00) 2797 { 2798 case 0x00: 2799 goto op_semantics_14; 2800 break; 2801 } 2802 break; 2803 case 0x0d: 2804 GETBYTE (); 2805 switch (op[3] & 0x00) 2806 { 2807 case 0x00: 2808 goto op_semantics_15; 2809 break; 2810 } 2811 break; 2812 case 0x10: 2813 GETBYTE (); 2814 switch (op[3] & 0x00) 2815 { 2816 case 0x00: 2817 goto op_semantics_16; 2818 break; 2819 } 2820 break; 2821 case 0x11: 2822 GETBYTE (); 2823 switch (op[3] & 0x00) 2824 { 2825 case 0x00: 2826 goto op_semantics_17; 2827 break; 2828 } 2829 break; 2830 case 0x15: 2831 GETBYTE (); 2832 switch (op[3] & 0x00) 2833 { 2834 case 0x00: 2835 goto op_semantics_18; 2836 break; 2837 } 2838 break; 2839 default: UNSUPPORTED(); break; 2840 } 2841 break; 2842 case 0xa3: 2843 GETBYTE (); 2844 switch (op[2] & 0xff) 2845 { 2846 case 0x00: 2847 GETBYTE (); 2848 switch (op[3] & 0x00) 2849 { 2850 case 0x00: 2851 goto op_semantics_7; 2852 break; 2853 } 2854 break; 2855 case 0x02: 2856 GETBYTE (); 2857 switch (op[3] & 0x00) 2858 { 2859 case 0x00: 2860 goto op_semantics_19; 2861 break; 2862 } 2863 break; 2864 case 0x04: 2865 GETBYTE (); 2866 switch (op[3] & 0x00) 2867 { 2868 case 0x00: 2869 goto op_semantics_8; 2870 break; 2871 } 2872 break; 2873 case 0x05: 2874 GETBYTE (); 2875 switch (op[3] & 0x00) 2876 { 2877 case 0x00: 2878 goto op_semantics_9; 2879 break; 2880 } 2881 break; 2882 case 0x06: 2883 GETBYTE (); 2884 switch (op[3] & 0x00) 2885 { 2886 case 0x00: 2887 goto op_semantics_10; 2888 break; 2889 } 2890 break; 2891 case 0x07: 2892 GETBYTE (); 2893 switch (op[3] & 0x00) 2894 { 2895 case 0x00: 2896 goto op_semantics_11; 2897 break; 2898 } 2899 break; 2900 case 0x08: 2901 GETBYTE (); 2902 switch (op[3] & 0x00) 2903 { 2904 case 0x00: 2905 goto op_semantics_12; 2906 break; 2907 } 2908 break; 2909 case 0x09: 2910 GETBYTE (); 2911 switch (op[3] & 0x00) 2912 { 2913 case 0x00: 2914 goto op_semantics_13; 2915 break; 2916 } 2917 break; 2918 case 0x0c: 2919 GETBYTE (); 2920 switch (op[3] & 0x00) 2921 { 2922 case 0x00: 2923 goto op_semantics_14; 2924 break; 2925 } 2926 break; 2927 case 0x0d: 2928 GETBYTE (); 2929 switch (op[3] & 0x00) 2930 { 2931 case 0x00: 2932 goto op_semantics_15; 2933 break; 2934 } 2935 break; 2936 case 0x10: 2937 GETBYTE (); 2938 switch (op[3] & 0x00) 2939 { 2940 case 0x00: 2941 goto op_semantics_16; 2942 break; 2943 } 2944 break; 2945 case 0x11: 2946 GETBYTE (); 2947 switch (op[3] & 0x00) 2948 { 2949 case 0x00: 2950 goto op_semantics_17; 2951 break; 2952 } 2953 break; 2954 case 0x15: 2955 GETBYTE (); 2956 switch (op[3] & 0x00) 2957 { 2958 case 0x00: 2959 goto op_semantics_18; 2960 break; 2961 } 2962 break; 2963 default: UNSUPPORTED(); break; 2964 } 2965 break; 2966 case 0xc0: 2967 GETBYTE (); 2968 switch (op[2] & 0x00) 2969 { 2970 case 0x00: 2971 goto op_semantics_1; 2972 break; 2973 } 2974 break; 2975 case 0xc1: 2976 GETBYTE (); 2977 switch (op[2] & 0x00) 2978 { 2979 case 0x00: 2980 goto op_semantics_1; 2981 break; 2982 } 2983 break; 2984 case 0xc2: 2985 GETBYTE (); 2986 switch (op[2] & 0x00) 2987 { 2988 case 0x00: 2989 goto op_semantics_1; 2990 break; 2991 } 2992 break; 2993 case 0xc3: 2994 GETBYTE (); 2995 switch (op[2] & 0x00) 2996 { 2997 case 0x00: 2998 goto op_semantics_1; 2999 break; 3000 } 3001 break; 3002 case 0xc4: 3003 GETBYTE (); 3004 switch (op[2] & 0x00) 3005 { 3006 case 0x00: 3007 goto op_semantics_2; 3008 break; 3009 } 3010 break; 3011 case 0xc5: 3012 GETBYTE (); 3013 switch (op[2] & 0x00) 3014 { 3015 case 0x00: 3016 goto op_semantics_2; 3017 break; 3018 } 3019 break; 3020 case 0xc6: 3021 GETBYTE (); 3022 switch (op[2] & 0x00) 3023 { 3024 case 0x00: 3025 goto op_semantics_2; 3026 break; 3027 } 3028 break; 3029 case 0xc7: 3030 GETBYTE (); 3031 switch (op[2] & 0x00) 3032 { 3033 case 0x00: 3034 goto op_semantics_2; 3035 break; 3036 } 3037 break; 3038 case 0xc8: 3039 GETBYTE (); 3040 switch (op[2] & 0x00) 3041 { 3042 case 0x00: 3043 goto op_semantics_3; 3044 break; 3045 } 3046 break; 3047 case 0xc9: 3048 GETBYTE (); 3049 switch (op[2] & 0x00) 3050 { 3051 case 0x00: 3052 goto op_semantics_3; 3053 break; 3054 } 3055 break; 3056 case 0xca: 3057 GETBYTE (); 3058 switch (op[2] & 0x00) 3059 { 3060 case 0x00: 3061 goto op_semantics_3; 3062 break; 3063 } 3064 break; 3065 case 0xcb: 3066 GETBYTE (); 3067 switch (op[2] & 0x00) 3068 { 3069 case 0x00: 3070 goto op_semantics_3; 3071 break; 3072 } 3073 break; 3074 case 0xcc: 3075 GETBYTE (); 3076 switch (op[2] & 0x00) 3077 { 3078 case 0x00: 3079 goto op_semantics_4; 3080 break; 3081 } 3082 break; 3083 case 0xcd: 3084 GETBYTE (); 3085 switch (op[2] & 0x00) 3086 { 3087 case 0x00: 3088 goto op_semantics_4; 3089 break; 3090 } 3091 break; 3092 case 0xce: 3093 GETBYTE (); 3094 switch (op[2] & 0x00) 3095 { 3096 case 0x00: 3097 goto op_semantics_4; 3098 break; 3099 } 3100 break; 3101 case 0xcf: 3102 GETBYTE (); 3103 switch (op[2] & 0x00) 3104 { 3105 case 0x00: 3106 goto op_semantics_4; 3107 break; 3108 } 3109 break; 3110 case 0xd0: 3111 GETBYTE (); 3112 switch (op[2] & 0x00) 3113 { 3114 case 0x00: 3115 goto op_semantics_5; 3116 break; 3117 } 3118 break; 3119 case 0xd1: 3120 GETBYTE (); 3121 switch (op[2] & 0x00) 3122 { 3123 case 0x00: 3124 goto op_semantics_5; 3125 break; 3126 } 3127 break; 3128 case 0xd2: 3129 GETBYTE (); 3130 switch (op[2] & 0x00) 3131 { 3132 case 0x00: 3133 goto op_semantics_5; 3134 break; 3135 } 3136 break; 3137 case 0xd3: 3138 GETBYTE (); 3139 switch (op[2] & 0x00) 3140 { 3141 case 0x00: 3142 goto op_semantics_5; 3143 break; 3144 } 3145 break; 3146 case 0xd4: 3147 GETBYTE (); 3148 switch (op[2] & 0x00) 3149 { 3150 case 0x00: 3151 goto op_semantics_6; 3152 break; 3153 } 3154 break; 3155 case 0xd5: 3156 GETBYTE (); 3157 switch (op[2] & 0x00) 3158 { 3159 case 0x00: 3160 goto op_semantics_6; 3161 break; 3162 } 3163 break; 3164 case 0xd6: 3165 GETBYTE (); 3166 switch (op[2] & 0x00) 3167 { 3168 case 0x00: 3169 goto op_semantics_6; 3170 break; 3171 } 3172 break; 3173 case 0xd7: 3174 GETBYTE (); 3175 switch (op[2] & 0x00) 3176 { 3177 case 0x00: 3178 goto op_semantics_6; 3179 break; 3180 } 3181 break; 3182 case 0xe0: 3183 GETBYTE (); 3184 switch (op[2] & 0xff) 3185 { 3186 case 0x00: 3187 GETBYTE (); 3188 switch (op[3] & 0x00) 3189 { 3190 case 0x00: 3191 goto op_semantics_7; 3192 break; 3193 } 3194 break; 3195 case 0x04: 3196 GETBYTE (); 3197 switch (op[3] & 0x00) 3198 { 3199 case 0x00: 3200 goto op_semantics_8; 3201 break; 3202 } 3203 break; 3204 case 0x05: 3205 GETBYTE (); 3206 switch (op[3] & 0x00) 3207 { 3208 case 0x00: 3209 goto op_semantics_9; 3210 break; 3211 } 3212 break; 3213 case 0x06: 3214 GETBYTE (); 3215 switch (op[3] & 0x00) 3216 { 3217 case 0x00: 3218 goto op_semantics_10; 3219 break; 3220 } 3221 break; 3222 case 0x07: 3223 GETBYTE (); 3224 switch (op[3] & 0x00) 3225 { 3226 case 0x00: 3227 goto op_semantics_11; 3228 break; 3229 } 3230 break; 3231 case 0x08: 3232 GETBYTE (); 3233 switch (op[3] & 0x00) 3234 { 3235 case 0x00: 3236 goto op_semantics_12; 3237 break; 3238 } 3239 break; 3240 case 0x09: 3241 GETBYTE (); 3242 switch (op[3] & 0x00) 3243 { 3244 case 0x00: 3245 goto op_semantics_13; 3246 break; 3247 } 3248 break; 3249 case 0x0c: 3250 GETBYTE (); 3251 switch (op[3] & 0x00) 3252 { 3253 case 0x00: 3254 goto op_semantics_14; 3255 break; 3256 } 3257 break; 3258 case 0x0d: 3259 GETBYTE (); 3260 switch (op[3] & 0x00) 3261 { 3262 case 0x00: 3263 goto op_semantics_15; 3264 break; 3265 } 3266 break; 3267 case 0x10: 3268 GETBYTE (); 3269 switch (op[3] & 0x00) 3270 { 3271 case 0x00: 3272 goto op_semantics_16; 3273 break; 3274 } 3275 break; 3276 case 0x11: 3277 GETBYTE (); 3278 switch (op[3] & 0x00) 3279 { 3280 case 0x00: 3281 goto op_semantics_17; 3282 break; 3283 } 3284 break; 3285 case 0x15: 3286 GETBYTE (); 3287 switch (op[3] & 0x00) 3288 { 3289 case 0x00: 3290 goto op_semantics_18; 3291 break; 3292 } 3293 break; 3294 default: UNSUPPORTED(); break; 3295 } 3296 break; 3297 case 0xe1: 3298 GETBYTE (); 3299 switch (op[2] & 0xff) 3300 { 3301 case 0x00: 3302 GETBYTE (); 3303 switch (op[3] & 0x00) 3304 { 3305 case 0x00: 3306 goto op_semantics_7; 3307 break; 3308 } 3309 break; 3310 case 0x04: 3311 GETBYTE (); 3312 switch (op[3] & 0x00) 3313 { 3314 case 0x00: 3315 goto op_semantics_8; 3316 break; 3317 } 3318 break; 3319 case 0x05: 3320 GETBYTE (); 3321 switch (op[3] & 0x00) 3322 { 3323 case 0x00: 3324 goto op_semantics_9; 3325 break; 3326 } 3327 break; 3328 case 0x06: 3329 GETBYTE (); 3330 switch (op[3] & 0x00) 3331 { 3332 case 0x00: 3333 goto op_semantics_10; 3334 break; 3335 } 3336 break; 3337 case 0x07: 3338 GETBYTE (); 3339 switch (op[3] & 0x00) 3340 { 3341 case 0x00: 3342 goto op_semantics_11; 3343 break; 3344 } 3345 break; 3346 case 0x08: 3347 GETBYTE (); 3348 switch (op[3] & 0x00) 3349 { 3350 case 0x00: 3351 goto op_semantics_12; 3352 break; 3353 } 3354 break; 3355 case 0x09: 3356 GETBYTE (); 3357 switch (op[3] & 0x00) 3358 { 3359 case 0x00: 3360 goto op_semantics_13; 3361 break; 3362 } 3363 break; 3364 case 0x0c: 3365 GETBYTE (); 3366 switch (op[3] & 0x00) 3367 { 3368 case 0x00: 3369 goto op_semantics_14; 3370 break; 3371 } 3372 break; 3373 case 0x0d: 3374 GETBYTE (); 3375 switch (op[3] & 0x00) 3376 { 3377 case 0x00: 3378 goto op_semantics_15; 3379 break; 3380 } 3381 break; 3382 case 0x10: 3383 GETBYTE (); 3384 switch (op[3] & 0x00) 3385 { 3386 case 0x00: 3387 goto op_semantics_16; 3388 break; 3389 } 3390 break; 3391 case 0x11: 3392 GETBYTE (); 3393 switch (op[3] & 0x00) 3394 { 3395 case 0x00: 3396 goto op_semantics_17; 3397 break; 3398 } 3399 break; 3400 case 0x15: 3401 GETBYTE (); 3402 switch (op[3] & 0x00) 3403 { 3404 case 0x00: 3405 goto op_semantics_18; 3406 break; 3407 } 3408 break; 3409 default: UNSUPPORTED(); break; 3410 } 3411 break; 3412 case 0xe2: 3413 GETBYTE (); 3414 switch (op[2] & 0xff) 3415 { 3416 case 0x00: 3417 GETBYTE (); 3418 switch (op[3] & 0x00) 3419 { 3420 case 0x00: 3421 goto op_semantics_7; 3422 break; 3423 } 3424 break; 3425 case 0x04: 3426 GETBYTE (); 3427 switch (op[3] & 0x00) 3428 { 3429 case 0x00: 3430 goto op_semantics_8; 3431 break; 3432 } 3433 break; 3434 case 0x05: 3435 GETBYTE (); 3436 switch (op[3] & 0x00) 3437 { 3438 case 0x00: 3439 goto op_semantics_9; 3440 break; 3441 } 3442 break; 3443 case 0x06: 3444 GETBYTE (); 3445 switch (op[3] & 0x00) 3446 { 3447 case 0x00: 3448 goto op_semantics_10; 3449 break; 3450 } 3451 break; 3452 case 0x07: 3453 GETBYTE (); 3454 switch (op[3] & 0x00) 3455 { 3456 case 0x00: 3457 goto op_semantics_11; 3458 break; 3459 } 3460 break; 3461 case 0x08: 3462 GETBYTE (); 3463 switch (op[3] & 0x00) 3464 { 3465 case 0x00: 3466 goto op_semantics_12; 3467 break; 3468 } 3469 break; 3470 case 0x09: 3471 GETBYTE (); 3472 switch (op[3] & 0x00) 3473 { 3474 case 0x00: 3475 goto op_semantics_13; 3476 break; 3477 } 3478 break; 3479 case 0x0c: 3480 GETBYTE (); 3481 switch (op[3] & 0x00) 3482 { 3483 case 0x00: 3484 goto op_semantics_14; 3485 break; 3486 } 3487 break; 3488 case 0x0d: 3489 GETBYTE (); 3490 switch (op[3] & 0x00) 3491 { 3492 case 0x00: 3493 goto op_semantics_15; 3494 break; 3495 } 3496 break; 3497 case 0x10: 3498 GETBYTE (); 3499 switch (op[3] & 0x00) 3500 { 3501 case 0x00: 3502 goto op_semantics_16; 3503 break; 3504 } 3505 break; 3506 case 0x11: 3507 GETBYTE (); 3508 switch (op[3] & 0x00) 3509 { 3510 case 0x00: 3511 goto op_semantics_17; 3512 break; 3513 } 3514 break; 3515 case 0x15: 3516 GETBYTE (); 3517 switch (op[3] & 0x00) 3518 { 3519 case 0x00: 3520 goto op_semantics_18; 3521 break; 3522 } 3523 break; 3524 default: UNSUPPORTED(); break; 3525 } 3526 break; 3527 case 0xe3: 3528 GETBYTE (); 3529 switch (op[2] & 0xff) 3530 { 3531 case 0x00: 3532 GETBYTE (); 3533 switch (op[3] & 0x00) 3534 { 3535 case 0x00: 3536 goto op_semantics_7; 3537 break; 3538 } 3539 break; 3540 case 0x04: 3541 GETBYTE (); 3542 switch (op[3] & 0x00) 3543 { 3544 case 0x00: 3545 goto op_semantics_8; 3546 break; 3547 } 3548 break; 3549 case 0x05: 3550 GETBYTE (); 3551 switch (op[3] & 0x00) 3552 { 3553 case 0x00: 3554 goto op_semantics_9; 3555 break; 3556 } 3557 break; 3558 case 0x06: 3559 GETBYTE (); 3560 switch (op[3] & 0x00) 3561 { 3562 case 0x00: 3563 goto op_semantics_10; 3564 break; 3565 } 3566 break; 3567 case 0x07: 3568 GETBYTE (); 3569 switch (op[3] & 0x00) 3570 { 3571 case 0x00: 3572 goto op_semantics_11; 3573 break; 3574 } 3575 break; 3576 case 0x08: 3577 GETBYTE (); 3578 switch (op[3] & 0x00) 3579 { 3580 case 0x00: 3581 goto op_semantics_12; 3582 break; 3583 } 3584 break; 3585 case 0x09: 3586 GETBYTE (); 3587 switch (op[3] & 0x00) 3588 { 3589 case 0x00: 3590 goto op_semantics_13; 3591 break; 3592 } 3593 break; 3594 case 0x0c: 3595 GETBYTE (); 3596 switch (op[3] & 0x00) 3597 { 3598 case 0x00: 3599 goto op_semantics_14; 3600 break; 3601 } 3602 break; 3603 case 0x0d: 3604 GETBYTE (); 3605 switch (op[3] & 0x00) 3606 { 3607 case 0x00: 3608 goto op_semantics_15; 3609 break; 3610 } 3611 break; 3612 case 0x10: 3613 GETBYTE (); 3614 switch (op[3] & 0x00) 3615 { 3616 case 0x00: 3617 goto op_semantics_16; 3618 break; 3619 } 3620 break; 3621 case 0x11: 3622 GETBYTE (); 3623 switch (op[3] & 0x00) 3624 { 3625 case 0x00: 3626 goto op_semantics_17; 3627 break; 3628 } 3629 break; 3630 case 0x15: 3631 GETBYTE (); 3632 switch (op[3] & 0x00) 3633 { 3634 case 0x00: 3635 goto op_semantics_18; 3636 break; 3637 } 3638 break; 3639 default: UNSUPPORTED(); break; 3640 } 3641 break; 3642 default: UNSUPPORTED(); break; 3643 } 3644 break; 3645 case 0x08: 3646 case 0x09: 3647 case 0x0a: 3648 case 0x0b: 3649 case 0x0c: 3650 case 0x0d: 3651 case 0x0e: 3652 case 0x0f: 3653 { 3654 /** 0000 1dsp bra.s %a0 */ 3655 #line 779 "rx-decode.opc" 3656 int dsp AU = op[0] & 0x07; 3657 if (trace) 3658 { 3659 printf ("\033[33m%s\033[0m %02x\n", 3660 "/** 0000 1dsp bra.s %a0 */", 3661 op[0]); 3662 printf (" dsp = 0x%x\n", dsp); 3663 } 3664 SYNTAX("bra.s %a0"); 3665 #line 779 "rx-decode.opc" 3666 ID(branch); DC(pc + dsp3map[dsp]); 3667 3668 } 3669 break; 3670 case 0x10: 3671 case 0x11: 3672 case 0x12: 3673 case 0x13: 3674 case 0x14: 3675 case 0x15: 3676 case 0x16: 3677 case 0x17: 3678 case 0x18: 3679 case 0x19: 3680 case 0x1a: 3681 case 0x1b: 3682 case 0x1c: 3683 case 0x1d: 3684 case 0x1e: 3685 case 0x1f: 3686 { 3687 /** 0001 n dsp b%1.s %a0 */ 3688 #line 769 "rx-decode.opc" 3689 int n AU = (op[0] >> 3) & 0x01; 3690 #line 769 "rx-decode.opc" 3691 int dsp AU = op[0] & 0x07; 3692 if (trace) 3693 { 3694 printf ("\033[33m%s\033[0m %02x\n", 3695 "/** 0001 n dsp b%1.s %a0 */", 3696 op[0]); 3697 printf (" n = 0x%x,", n); 3698 printf (" dsp = 0x%x\n", dsp); 3699 } 3700 SYNTAX("b%1.s %a0"); 3701 #line 769 "rx-decode.opc" 3702 ID(branch); Scc(n); DC(pc + dsp3map[dsp]); 3703 3704 } 3705 break; 3706 case 0x20: 3707 case 0x21: 3708 case 0x22: 3709 case 0x23: 3710 case 0x24: 3711 case 0x25: 3712 case 0x26: 3713 case 0x27: 3714 case 0x28: 3715 case 0x29: 3716 case 0x2a: 3717 case 0x2b: 3718 case 0x2c: 3719 case 0x2d: 3720 case 0x2f: 3721 { 3722 /** 0010 cond b%1.b %a0 */ 3723 #line 772 "rx-decode.opc" 3724 int cond AU = op[0] & 0x0f; 3725 if (trace) 3726 { 3727 printf ("\033[33m%s\033[0m %02x\n", 3728 "/** 0010 cond b%1.b %a0 */", 3729 op[0]); 3730 printf (" cond = 0x%x\n", cond); 3731 } 3732 SYNTAX("b%1.b %a0"); 3733 #line 772 "rx-decode.opc" 3734 ID(branch); Scc(cond); DC(pc + IMMex (1)); 3735 3736 } 3737 break; 3738 case 0x2e: 3739 { 3740 /** 0010 1110 bra.b %a0 */ 3741 if (trace) 3742 { 3743 printf ("\033[33m%s\033[0m %02x\n", 3744 "/** 0010 1110 bra.b %a0 */", 3745 op[0]); 3746 } 3747 SYNTAX("bra.b %a0"); 3748 #line 782 "rx-decode.opc" 3749 ID(branch); DC(pc + IMMex(1)); 3750 3751 } 3752 break; 3753 case 0x38: 3754 { 3755 /** 0011 1000 bra.w %a0 */ 3756 if (trace) 3757 { 3758 printf ("\033[33m%s\033[0m %02x\n", 3759 "/** 0011 1000 bra.w %a0 */", 3760 op[0]); 3761 } 3762 SYNTAX("bra.w %a0"); 3763 #line 785 "rx-decode.opc" 3764 ID(branch); DC(pc + IMMex(2)); 3765 3766 } 3767 break; 3768 case 0x39: 3769 { 3770 /** 0011 1001 bsr.w %a0 */ 3771 if (trace) 3772 { 3773 printf ("\033[33m%s\033[0m %02x\n", 3774 "/** 0011 1001 bsr.w %a0 */", 3775 op[0]); 3776 } 3777 SYNTAX("bsr.w %a0"); 3778 #line 801 "rx-decode.opc" 3779 ID(jsr); DC(pc + IMMex(2)); 3780 3781 } 3782 break; 3783 case 0x3a: 3784 case 0x3b: 3785 { 3786 /** 0011 101c b%1.w %a0 */ 3787 #line 775 "rx-decode.opc" 3788 int c AU = op[0] & 0x01; 3789 if (trace) 3790 { 3791 printf ("\033[33m%s\033[0m %02x\n", 3792 "/** 0011 101c b%1.w %a0 */", 3793 op[0]); 3794 printf (" c = 0x%x\n", c); 3795 } 3796 SYNTAX("b%1.w %a0"); 3797 #line 775 "rx-decode.opc" 3798 ID(branch); Scc(c); DC(pc + IMMex (2)); 3799 3800 3801 } 3802 break; 3803 case 0x3c: 3804 GETBYTE (); 3805 switch (op[1] & 0x00) 3806 { 3807 case 0x00: 3808 op_semantics_20: 3809 { 3810 /** 0011 11sz d dst sppp mov%s #%1, %0 */ 3811 #line 311 "rx-decode.opc" 3812 int sz AU = op[0] & 0x03; 3813 #line 311 "rx-decode.opc" 3814 int d AU = (op[1] >> 7) & 0x01; 3815 #line 311 "rx-decode.opc" 3816 int dst AU = (op[1] >> 4) & 0x07; 3817 #line 311 "rx-decode.opc" 3818 int sppp AU = op[1] & 0x0f; 3819 if (trace) 3820 { 3821 printf ("\033[33m%s\033[0m %02x %02x\n", 3822 "/** 0011 11sz d dst sppp mov%s #%1, %0 */", 3823 op[0], op[1]); 3824 printf (" sz = 0x%x,", sz); 3825 printf (" d = 0x%x,", d); 3826 printf (" dst = 0x%x,", dst); 3827 printf (" sppp = 0x%x\n", sppp); 3828 } 3829 SYNTAX("mov%s #%1, %0"); 3830 #line 311 "rx-decode.opc" 3831 ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F_____; 3832 3833 } 3834 break; 3835 } 3836 break; 3837 case 0x3d: 3838 GETBYTE (); 3839 switch (op[1] & 0x00) 3840 { 3841 case 0x00: 3842 goto op_semantics_20; 3843 break; 3844 } 3845 break; 3846 case 0x3e: 3847 GETBYTE (); 3848 switch (op[1] & 0x00) 3849 { 3850 case 0x00: 3851 goto op_semantics_20; 3852 break; 3853 } 3854 break; 3855 case 0x3f: 3856 GETBYTE (); 3857 switch (op[1] & 0x00) 3858 { 3859 case 0x00: 3860 { 3861 /** 0011 1111 rega regb rtsd #%1, %2-%0 */ 3862 #line 408 "rx-decode.opc" 3863 int rega AU = (op[1] >> 4) & 0x0f; 3864 #line 408 "rx-decode.opc" 3865 int regb AU = op[1] & 0x0f; 3866 if (trace) 3867 { 3868 printf ("\033[33m%s\033[0m %02x %02x\n", 3869 "/** 0011 1111 rega regb rtsd #%1, %2-%0 */", 3870 op[0], op[1]); 3871 printf (" rega = 0x%x,", rega); 3872 printf (" regb = 0x%x\n", regb); 3873 } 3874 SYNTAX("rtsd #%1, %2-%0"); 3875 #line 408 "rx-decode.opc" 3876 ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb); 3877 3878 /*----------------------------------------------------------------------*/ 3879 /* AND */ 3880 3881 } 3882 break; 3883 } 3884 break; 3885 case 0x40: 3886 GETBYTE (); 3887 switch (op[1] & 0x00) 3888 { 3889 case 0x00: 3890 op_semantics_21: 3891 { 3892 /** 0100 00ss rsrc rdst sub %2%S2, %1 */ 3893 #line 543 "rx-decode.opc" 3894 int ss AU = op[0] & 0x03; 3895 #line 543 "rx-decode.opc" 3896 int rsrc AU = (op[1] >> 4) & 0x0f; 3897 #line 543 "rx-decode.opc" 3898 int rdst AU = op[1] & 0x0f; 3899 if (trace) 3900 { 3901 printf ("\033[33m%s\033[0m %02x %02x\n", 3902 "/** 0100 00ss rsrc rdst sub %2%S2, %1 */", 3903 op[0], op[1]); 3904 printf (" ss = 0x%x,", ss); 3905 printf (" rsrc = 0x%x,", rsrc); 3906 printf (" rdst = 0x%x\n", rdst); 3907 } 3908 SYNTAX("sub %2%S2, %1"); 3909 #line 543 "rx-decode.opc" 3910 ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F_OSZC; 3911 3912 } 3913 break; 3914 } 3915 break; 3916 case 0x41: 3917 GETBYTE (); 3918 switch (op[1] & 0x00) 3919 { 3920 case 0x00: 3921 goto op_semantics_21; 3922 break; 3923 } 3924 break; 3925 case 0x42: 3926 GETBYTE (); 3927 switch (op[1] & 0x00) 3928 { 3929 case 0x00: 3930 goto op_semantics_21; 3931 break; 3932 } 3933 break; 3934 case 0x43: 3935 GETBYTE (); 3936 switch (op[1] & 0x00) 3937 { 3938 case 0x00: 3939 goto op_semantics_21; 3940 break; 3941 } 3942 break; 3943 case 0x44: 3944 GETBYTE (); 3945 switch (op[1] & 0x00) 3946 { 3947 case 0x00: 3948 op_semantics_22: 3949 { 3950 /** 0100 01ss rsrc rdst cmp %2%S2, %1 */ 3951 #line 531 "rx-decode.opc" 3952 int ss AU = op[0] & 0x03; 3953 #line 531 "rx-decode.opc" 3954 int rsrc AU = (op[1] >> 4) & 0x0f; 3955 #line 531 "rx-decode.opc" 3956 int rdst AU = op[1] & 0x0f; 3957 if (trace) 3958 { 3959 printf ("\033[33m%s\033[0m %02x %02x\n", 3960 "/** 0100 01ss rsrc rdst cmp %2%S2, %1 */", 3961 op[0], op[1]); 3962 printf (" ss = 0x%x,", ss); 3963 printf (" rsrc = 0x%x,", rsrc); 3964 printf (" rdst = 0x%x\n", rdst); 3965 } 3966 SYNTAX("cmp %2%S2, %1"); 3967 #line 531 "rx-decode.opc" 3968 ID(sub); S2P(ss, rsrc); SR(rdst); F_OSZC; 3969 3970 } 3971 break; 3972 } 3973 break; 3974 case 0x45: 3975 GETBYTE (); 3976 switch (op[1] & 0x00) 3977 { 3978 case 0x00: 3979 goto op_semantics_22; 3980 break; 3981 } 3982 break; 3983 case 0x46: 3984 GETBYTE (); 3985 switch (op[1] & 0x00) 3986 { 3987 case 0x00: 3988 goto op_semantics_22; 3989 break; 3990 } 3991 break; 3992 case 0x47: 3993 GETBYTE (); 3994 switch (op[1] & 0x00) 3995 { 3996 case 0x00: 3997 goto op_semantics_22; 3998 break; 3999 } 4000 break; 4001 case 0x48: 4002 GETBYTE (); 4003 switch (op[1] & 0x00) 4004 { 4005 case 0x00: 4006 op_semantics_23: 4007 { 4008 /** 0100 10ss rsrc rdst add %1%S1, %0 */ 4009 #line 507 "rx-decode.opc" 4010 int ss AU = op[0] & 0x03; 4011 #line 507 "rx-decode.opc" 4012 int rsrc AU = (op[1] >> 4) & 0x0f; 4013 #line 507 "rx-decode.opc" 4014 int rdst AU = op[1] & 0x0f; 4015 if (trace) 4016 { 4017 printf ("\033[33m%s\033[0m %02x %02x\n", 4018 "/** 0100 10ss rsrc rdst add %1%S1, %0 */", 4019 op[0], op[1]); 4020 printf (" ss = 0x%x,", ss); 4021 printf (" rsrc = 0x%x,", rsrc); 4022 printf (" rdst = 0x%x\n", rdst); 4023 } 4024 SYNTAX("add %1%S1, %0"); 4025 #line 507 "rx-decode.opc" 4026 ID(add); SP(ss, rsrc); DR(rdst); F_OSZC; 4027 4028 } 4029 break; 4030 } 4031 break; 4032 case 0x49: 4033 GETBYTE (); 4034 switch (op[1] & 0x00) 4035 { 4036 case 0x00: 4037 goto op_semantics_23; 4038 break; 4039 } 4040 break; 4041 case 0x4a: 4042 GETBYTE (); 4043 switch (op[1] & 0x00) 4044 { 4045 case 0x00: 4046 goto op_semantics_23; 4047 break; 4048 } 4049 break; 4050 case 0x4b: 4051 GETBYTE (); 4052 switch (op[1] & 0x00) 4053 { 4054 case 0x00: 4055 goto op_semantics_23; 4056 break; 4057 } 4058 break; 4059 case 0x4c: 4060 GETBYTE (); 4061 switch (op[1] & 0x00) 4062 { 4063 case 0x00: 4064 op_semantics_24: 4065 { 4066 /** 0100 11ss rsrc rdst mul %1%S1, %0 */ 4067 #line 650 "rx-decode.opc" 4068 int ss AU = op[0] & 0x03; 4069 #line 650 "rx-decode.opc" 4070 int rsrc AU = (op[1] >> 4) & 0x0f; 4071 #line 650 "rx-decode.opc" 4072 int rdst AU = op[1] & 0x0f; 4073 if (trace) 4074 { 4075 printf ("\033[33m%s\033[0m %02x %02x\n", 4076 "/** 0100 11ss rsrc rdst mul %1%S1, %0 */", 4077 op[0], op[1]); 4078 printf (" ss = 0x%x,", ss); 4079 printf (" rsrc = 0x%x,", rsrc); 4080 printf (" rdst = 0x%x\n", rdst); 4081 } 4082 SYNTAX("mul %1%S1, %0"); 4083 #line 650 "rx-decode.opc" 4084 ID(mul); SP(ss, rsrc); DR(rdst); F_____; 4085 4086 } 4087 break; 4088 } 4089 break; 4090 case 0x4d: 4091 GETBYTE (); 4092 switch (op[1] & 0x00) 4093 { 4094 case 0x00: 4095 goto op_semantics_24; 4096 break; 4097 } 4098 break; 4099 case 0x4e: 4100 GETBYTE (); 4101 switch (op[1] & 0x00) 4102 { 4103 case 0x00: 4104 goto op_semantics_24; 4105 break; 4106 } 4107 break; 4108 case 0x4f: 4109 GETBYTE (); 4110 switch (op[1] & 0x00) 4111 { 4112 case 0x00: 4113 goto op_semantics_24; 4114 break; 4115 } 4116 break; 4117 case 0x50: 4118 GETBYTE (); 4119 switch (op[1] & 0x00) 4120 { 4121 case 0x00: 4122 op_semantics_25: 4123 { 4124 /** 0101 00ss rsrc rdst and %1%S1, %0 */ 4125 #line 420 "rx-decode.opc" 4126 int ss AU = op[0] & 0x03; 4127 #line 420 "rx-decode.opc" 4128 int rsrc AU = (op[1] >> 4) & 0x0f; 4129 #line 420 "rx-decode.opc" 4130 int rdst AU = op[1] & 0x0f; 4131 if (trace) 4132 { 4133 printf ("\033[33m%s\033[0m %02x %02x\n", 4134 "/** 0101 00ss rsrc rdst and %1%S1, %0 */", 4135 op[0], op[1]); 4136 printf (" ss = 0x%x,", ss); 4137 printf (" rsrc = 0x%x,", rsrc); 4138 printf (" rdst = 0x%x\n", rdst); 4139 } 4140 SYNTAX("and %1%S1, %0"); 4141 #line 420 "rx-decode.opc" 4142 ID(and); SP(ss, rsrc); DR(rdst); F__SZ_; 4143 4144 } 4145 break; 4146 } 4147 break; 4148 case 0x51: 4149 GETBYTE (); 4150 switch (op[1] & 0x00) 4151 { 4152 case 0x00: 4153 goto op_semantics_25; 4154 break; 4155 } 4156 break; 4157 case 0x52: 4158 GETBYTE (); 4159 switch (op[1] & 0x00) 4160 { 4161 case 0x00: 4162 goto op_semantics_25; 4163 break; 4164 } 4165 break; 4166 case 0x53: 4167 GETBYTE (); 4168 switch (op[1] & 0x00) 4169 { 4170 case 0x00: 4171 goto op_semantics_25; 4172 break; 4173 } 4174 break; 4175 case 0x54: 4176 GETBYTE (); 4177 switch (op[1] & 0x00) 4178 { 4179 case 0x00: 4180 op_semantics_26: 4181 { 4182 /** 0101 01ss rsrc rdst or %1%S1, %0 */ 4183 #line 438 "rx-decode.opc" 4184 int ss AU = op[0] & 0x03; 4185 #line 438 "rx-decode.opc" 4186 int rsrc AU = (op[1] >> 4) & 0x0f; 4187 #line 438 "rx-decode.opc" 4188 int rdst AU = op[1] & 0x0f; 4189 if (trace) 4190 { 4191 printf ("\033[33m%s\033[0m %02x %02x\n", 4192 "/** 0101 01ss rsrc rdst or %1%S1, %0 */", 4193 op[0], op[1]); 4194 printf (" ss = 0x%x,", ss); 4195 printf (" rsrc = 0x%x,", rsrc); 4196 printf (" rdst = 0x%x\n", rdst); 4197 } 4198 SYNTAX("or %1%S1, %0"); 4199 #line 438 "rx-decode.opc" 4200 ID(or); SP(ss, rsrc); DR(rdst); F__SZ_; 4201 4202 } 4203 break; 4204 } 4205 break; 4206 case 0x55: 4207 GETBYTE (); 4208 switch (op[1] & 0x00) 4209 { 4210 case 0x00: 4211 goto op_semantics_26; 4212 break; 4213 } 4214 break; 4215 case 0x56: 4216 GETBYTE (); 4217 switch (op[1] & 0x00) 4218 { 4219 case 0x00: 4220 goto op_semantics_26; 4221 break; 4222 } 4223 break; 4224 case 0x57: 4225 GETBYTE (); 4226 switch (op[1] & 0x00) 4227 { 4228 case 0x00: 4229 goto op_semantics_26; 4230 break; 4231 } 4232 break; 4233 case 0x58: 4234 GETBYTE (); 4235 switch (op[1] & 0x00) 4236 { 4237 case 0x00: 4238 op_semantics_27: 4239 { 4240 /** 0101 1 s ss rsrc rdst movu%s %1, %0 */ 4241 #line 359 "rx-decode.opc" 4242 int s AU = (op[0] >> 2) & 0x01; 4243 #line 359 "rx-decode.opc" 4244 int ss AU = op[0] & 0x03; 4245 #line 359 "rx-decode.opc" 4246 int rsrc AU = (op[1] >> 4) & 0x0f; 4247 #line 359 "rx-decode.opc" 4248 int rdst AU = op[1] & 0x0f; 4249 if (trace) 4250 { 4251 printf ("\033[33m%s\033[0m %02x %02x\n", 4252 "/** 0101 1 s ss rsrc rdst movu%s %1, %0 */", 4253 op[0], op[1]); 4254 printf (" s = 0x%x,", s); 4255 printf (" ss = 0x%x,", ss); 4256 printf (" rsrc = 0x%x,", rsrc); 4257 printf (" rdst = 0x%x\n", rdst); 4258 } 4259 SYNTAX("movu%s %1, %0"); 4260 #line 359 "rx-decode.opc" 4261 ID(mov); uBW(s); SD(ss, rsrc, s); DR(rdst); F_____; 4262 4263 } 4264 break; 4265 } 4266 break; 4267 case 0x59: 4268 GETBYTE (); 4269 switch (op[1] & 0x00) 4270 { 4271 case 0x00: 4272 goto op_semantics_27; 4273 break; 4274 } 4275 break; 4276 case 0x5a: 4277 GETBYTE (); 4278 switch (op[1] & 0x00) 4279 { 4280 case 0x00: 4281 goto op_semantics_27; 4282 break; 4283 } 4284 break; 4285 case 0x5b: 4286 GETBYTE (); 4287 switch (op[1] & 0x00) 4288 { 4289 case 0x00: 4290 goto op_semantics_27; 4291 break; 4292 } 4293 break; 4294 case 0x5c: 4295 GETBYTE (); 4296 switch (op[1] & 0x00) 4297 { 4298 case 0x00: 4299 goto op_semantics_27; 4300 break; 4301 } 4302 break; 4303 case 0x5d: 4304 GETBYTE (); 4305 switch (op[1] & 0x00) 4306 { 4307 case 0x00: 4308 goto op_semantics_27; 4309 break; 4310 } 4311 break; 4312 case 0x5e: 4313 GETBYTE (); 4314 switch (op[1] & 0x00) 4315 { 4316 case 0x00: 4317 goto op_semantics_27; 4318 break; 4319 } 4320 break; 4321 case 0x5f: 4322 GETBYTE (); 4323 switch (op[1] & 0x00) 4324 { 4325 case 0x00: 4326 goto op_semantics_27; 4327 break; 4328 } 4329 break; 4330 case 0x60: 4331 GETBYTE (); 4332 switch (op[1] & 0x00) 4333 { 4334 case 0x00: 4335 { 4336 /** 0110 0000 immm rdst sub #%2, %0 */ 4337 #line 540 "rx-decode.opc" 4338 int immm AU = (op[1] >> 4) & 0x0f; 4339 #line 540 "rx-decode.opc" 4340 int rdst AU = op[1] & 0x0f; 4341 if (trace) 4342 { 4343 printf ("\033[33m%s\033[0m %02x %02x\n", 4344 "/** 0110 0000 immm rdst sub #%2, %0 */", 4345 op[0], op[1]); 4346 printf (" immm = 0x%x,", immm); 4347 printf (" rdst = 0x%x\n", rdst); 4348 } 4349 SYNTAX("sub #%2, %0"); 4350 #line 540 "rx-decode.opc" 4351 ID(sub); S2C(immm); SR(rdst); DR(rdst); F_OSZC; 4352 4353 } 4354 break; 4355 } 4356 break; 4357 case 0x61: 4358 GETBYTE (); 4359 switch (op[1] & 0x00) 4360 { 4361 case 0x00: 4362 { 4363 /** 0110 0001 immm rdst cmp #%2, %1 */ 4364 #line 522 "rx-decode.opc" 4365 int immm AU = (op[1] >> 4) & 0x0f; 4366 #line 522 "rx-decode.opc" 4367 int rdst AU = op[1] & 0x0f; 4368 if (trace) 4369 { 4370 printf ("\033[33m%s\033[0m %02x %02x\n", 4371 "/** 0110 0001 immm rdst cmp #%2, %1 */", 4372 op[0], op[1]); 4373 printf (" immm = 0x%x,", immm); 4374 printf (" rdst = 0x%x\n", rdst); 4375 } 4376 SYNTAX("cmp #%2, %1"); 4377 #line 522 "rx-decode.opc" 4378 ID(sub); S2C(immm); SR(rdst); F_OSZC; 4379 4380 } 4381 break; 4382 } 4383 break; 4384 case 0x62: 4385 GETBYTE (); 4386 switch (op[1] & 0x00) 4387 { 4388 case 0x00: 4389 { 4390 /** 0110 0010 immm rdst add #%1, %0 */ 4391 #line 504 "rx-decode.opc" 4392 int immm AU = (op[1] >> 4) & 0x0f; 4393 #line 504 "rx-decode.opc" 4394 int rdst AU = op[1] & 0x0f; 4395 if (trace) 4396 { 4397 printf ("\033[33m%s\033[0m %02x %02x\n", 4398 "/** 0110 0010 immm rdst add #%1, %0 */", 4399 op[0], op[1]); 4400 printf (" immm = 0x%x,", immm); 4401 printf (" rdst = 0x%x\n", rdst); 4402 } 4403 SYNTAX("add #%1, %0"); 4404 #line 504 "rx-decode.opc" 4405 ID(add); SC(immm); DR(rdst); F_OSZC; 4406 4407 } 4408 break; 4409 } 4410 break; 4411 case 0x63: 4412 GETBYTE (); 4413 switch (op[1] & 0x00) 4414 { 4415 case 0x00: 4416 { 4417 /** 0110 0011 immm rdst mul #%1, %0 */ 4418 #line 616 "rx-decode.opc" 4419 int immm AU = (op[1] >> 4) & 0x0f; 4420 #line 616 "rx-decode.opc" 4421 int rdst AU = op[1] & 0x0f; 4422 if (trace) 4423 { 4424 printf ("\033[33m%s\033[0m %02x %02x\n", 4425 "/** 0110 0011 immm rdst mul #%1, %0 */", 4426 op[0], op[1]); 4427 printf (" immm = 0x%x,", immm); 4428 printf (" rdst = 0x%x\n", rdst); 4429 } 4430 SYNTAX("mul #%1, %0"); 4431 #line 616 "rx-decode.opc" 4432 if (immm == 1 && rdst == 0) 4433 { 4434 ID(nop2); 4435 SYNTAX ("nop\t; mul\t#1, r0"); 4436 } 4437 else 4438 { 4439 ID(mul); 4440 } 4441 DR(rdst); SC(immm); F_____; 4442 4443 } 4444 break; 4445 } 4446 break; 4447 case 0x64: 4448 GETBYTE (); 4449 switch (op[1] & 0x00) 4450 { 4451 case 0x00: 4452 { 4453 /** 0110 0100 immm rdst and #%1, %0 */ 4454 #line 414 "rx-decode.opc" 4455 int immm AU = (op[1] >> 4) & 0x0f; 4456 #line 414 "rx-decode.opc" 4457 int rdst AU = op[1] & 0x0f; 4458 if (trace) 4459 { 4460 printf ("\033[33m%s\033[0m %02x %02x\n", 4461 "/** 0110 0100 immm rdst and #%1, %0 */", 4462 op[0], op[1]); 4463 printf (" immm = 0x%x,", immm); 4464 printf (" rdst = 0x%x\n", rdst); 4465 } 4466 SYNTAX("and #%1, %0"); 4467 #line 414 "rx-decode.opc" 4468 ID(and); SC(immm); DR(rdst); F__SZ_; 4469 4470 } 4471 break; 4472 } 4473 break; 4474 case 0x65: 4475 GETBYTE (); 4476 switch (op[1] & 0x00) 4477 { 4478 case 0x00: 4479 { 4480 /** 0110 0101 immm rdst or #%1, %0 */ 4481 #line 432 "rx-decode.opc" 4482 int immm AU = (op[1] >> 4) & 0x0f; 4483 #line 432 "rx-decode.opc" 4484 int rdst AU = op[1] & 0x0f; 4485 if (trace) 4486 { 4487 printf ("\033[33m%s\033[0m %02x %02x\n", 4488 "/** 0110 0101 immm rdst or #%1, %0 */", 4489 op[0], op[1]); 4490 printf (" immm = 0x%x,", immm); 4491 printf (" rdst = 0x%x\n", rdst); 4492 } 4493 SYNTAX("or #%1, %0"); 4494 #line 432 "rx-decode.opc" 4495 ID(or); SC(immm); DR(rdst); F__SZ_; 4496 4497 } 4498 break; 4499 } 4500 break; 4501 case 0x66: 4502 GETBYTE (); 4503 switch (op[1] & 0x00) 4504 { 4505 case 0x00: 4506 { 4507 /** 0110 0110 immm rdst mov%s #%1, %0 */ 4508 #line 308 "rx-decode.opc" 4509 int immm AU = (op[1] >> 4) & 0x0f; 4510 #line 308 "rx-decode.opc" 4511 int rdst AU = op[1] & 0x0f; 4512 if (trace) 4513 { 4514 printf ("\033[33m%s\033[0m %02x %02x\n", 4515 "/** 0110 0110 immm rdst mov%s #%1, %0 */", 4516 op[0], op[1]); 4517 printf (" immm = 0x%x,", immm); 4518 printf (" rdst = 0x%x\n", rdst); 4519 } 4520 SYNTAX("mov%s #%1, %0"); 4521 #line 308 "rx-decode.opc" 4522 ID(mov); DR(rdst); SC(immm); F_____; 4523 4524 } 4525 break; 4526 } 4527 break; 4528 case 0x67: 4529 { 4530 /** 0110 0111 rtsd #%1 */ 4531 if (trace) 4532 { 4533 printf ("\033[33m%s\033[0m %02x\n", 4534 "/** 0110 0111 rtsd #%1 */", 4535 op[0]); 4536 } 4537 SYNTAX("rtsd #%1"); 4538 #line 405 "rx-decode.opc" 4539 ID(rtsd); SC(IMM(1) * 4); 4540 4541 } 4542 break; 4543 case 0x68: 4544 GETBYTE (); 4545 switch (op[1] & 0x00) 4546 { 4547 case 0x00: 4548 op_semantics_28: 4549 { 4550 /** 0110 100i mmmm rdst shlr #%2, %0 */ 4551 #line 730 "rx-decode.opc" 4552 int i AU = op[0] & 0x01; 4553 #line 730 "rx-decode.opc" 4554 int mmmm AU = (op[1] >> 4) & 0x0f; 4555 #line 730 "rx-decode.opc" 4556 int rdst AU = op[1] & 0x0f; 4557 if (trace) 4558 { 4559 printf ("\033[33m%s\033[0m %02x %02x\n", 4560 "/** 0110 100i mmmm rdst shlr #%2, %0 */", 4561 op[0], op[1]); 4562 printf (" i = 0x%x,", i); 4563 printf (" mmmm = 0x%x,", mmmm); 4564 printf (" rdst = 0x%x\n", rdst); 4565 } 4566 SYNTAX("shlr #%2, %0"); 4567 #line 730 "rx-decode.opc" 4568 ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F__SZC; 4569 4570 } 4571 break; 4572 } 4573 break; 4574 case 0x69: 4575 GETBYTE (); 4576 switch (op[1] & 0x00) 4577 { 4578 case 0x00: 4579 goto op_semantics_28; 4580 break; 4581 } 4582 break; 4583 case 0x6a: 4584 GETBYTE (); 4585 switch (op[1] & 0x00) 4586 { 4587 case 0x00: 4588 op_semantics_29: 4589 { 4590 /** 0110 101i mmmm rdst shar #%2, %0 */ 4591 #line 720 "rx-decode.opc" 4592 int i AU = op[0] & 0x01; 4593 #line 720 "rx-decode.opc" 4594 int mmmm AU = (op[1] >> 4) & 0x0f; 4595 #line 720 "rx-decode.opc" 4596 int rdst AU = op[1] & 0x0f; 4597 if (trace) 4598 { 4599 printf ("\033[33m%s\033[0m %02x %02x\n", 4600 "/** 0110 101i mmmm rdst shar #%2, %0 */", 4601 op[0], op[1]); 4602 printf (" i = 0x%x,", i); 4603 printf (" mmmm = 0x%x,", mmmm); 4604 printf (" rdst = 0x%x\n", rdst); 4605 } 4606 SYNTAX("shar #%2, %0"); 4607 #line 720 "rx-decode.opc" 4608 ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_0SZC; 4609 4610 } 4611 break; 4612 } 4613 break; 4614 case 0x6b: 4615 GETBYTE (); 4616 switch (op[1] & 0x00) 4617 { 4618 case 0x00: 4619 goto op_semantics_29; 4620 break; 4621 } 4622 break; 4623 case 0x6c: 4624 GETBYTE (); 4625 switch (op[1] & 0x00) 4626 { 4627 case 0x00: 4628 op_semantics_30: 4629 { 4630 /** 0110 110i mmmm rdst shll #%2, %0 */ 4631 #line 710 "rx-decode.opc" 4632 int i AU = op[0] & 0x01; 4633 #line 710 "rx-decode.opc" 4634 int mmmm AU = (op[1] >> 4) & 0x0f; 4635 #line 710 "rx-decode.opc" 4636 int rdst AU = op[1] & 0x0f; 4637 if (trace) 4638 { 4639 printf ("\033[33m%s\033[0m %02x %02x\n", 4640 "/** 0110 110i mmmm rdst shll #%2, %0 */", 4641 op[0], op[1]); 4642 printf (" i = 0x%x,", i); 4643 printf (" mmmm = 0x%x,", mmmm); 4644 printf (" rdst = 0x%x\n", rdst); 4645 } 4646 SYNTAX("shll #%2, %0"); 4647 #line 710 "rx-decode.opc" 4648 ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_OSZC; 4649 4650 } 4651 break; 4652 } 4653 break; 4654 case 0x6d: 4655 GETBYTE (); 4656 switch (op[1] & 0x00) 4657 { 4658 case 0x00: 4659 goto op_semantics_30; 4660 break; 4661 } 4662 break; 4663 case 0x6e: 4664 GETBYTE (); 4665 switch (op[1] & 0x00) 4666 { 4667 case 0x00: 4668 { 4669 /** 0110 1110 dsta dstb pushm %1-%2 */ 4670 #line 372 "rx-decode.opc" 4671 int dsta AU = (op[1] >> 4) & 0x0f; 4672 #line 372 "rx-decode.opc" 4673 int dstb AU = op[1] & 0x0f; 4674 if (trace) 4675 { 4676 printf ("\033[33m%s\033[0m %02x %02x\n", 4677 "/** 0110 1110 dsta dstb pushm %1-%2 */", 4678 op[0], op[1]); 4679 printf (" dsta = 0x%x,", dsta); 4680 printf (" dstb = 0x%x\n", dstb); 4681 } 4682 SYNTAX("pushm %1-%2"); 4683 #line 372 "rx-decode.opc" 4684 ID(pushm); SR(dsta); S2R(dstb); F_____; 4685 4686 } 4687 break; 4688 } 4689 break; 4690 case 0x6f: 4691 GETBYTE (); 4692 switch (op[1] & 0x00) 4693 { 4694 case 0x00: 4695 { 4696 /** 0110 1111 dsta dstb popm %1-%2 */ 4697 #line 369 "rx-decode.opc" 4698 int dsta AU = (op[1] >> 4) & 0x0f; 4699 #line 369 "rx-decode.opc" 4700 int dstb AU = op[1] & 0x0f; 4701 if (trace) 4702 { 4703 printf ("\033[33m%s\033[0m %02x %02x\n", 4704 "/** 0110 1111 dsta dstb popm %1-%2 */", 4705 op[0], op[1]); 4706 printf (" dsta = 0x%x,", dsta); 4707 printf (" dstb = 0x%x\n", dstb); 4708 } 4709 SYNTAX("popm %1-%2"); 4710 #line 369 "rx-decode.opc" 4711 ID(popm); SR(dsta); S2R(dstb); F_____; 4712 4713 } 4714 break; 4715 } 4716 break; 4717 case 0x70: 4718 GETBYTE (); 4719 switch (op[1] & 0x00) 4720 { 4721 case 0x00: 4722 op_semantics_31: 4723 { 4724 /** 0111 00im rsrc rdst add #%1, %2, %0 */ 4725 #line 513 "rx-decode.opc" 4726 int im AU = op[0] & 0x03; 4727 #line 513 "rx-decode.opc" 4728 int rsrc AU = (op[1] >> 4) & 0x0f; 4729 #line 513 "rx-decode.opc" 4730 int rdst AU = op[1] & 0x0f; 4731 if (trace) 4732 { 4733 printf ("\033[33m%s\033[0m %02x %02x\n", 4734 "/** 0111 00im rsrc rdst add #%1, %2, %0 */", 4735 op[0], op[1]); 4736 printf (" im = 0x%x,", im); 4737 printf (" rsrc = 0x%x,", rsrc); 4738 printf (" rdst = 0x%x\n", rdst); 4739 } 4740 SYNTAX("add #%1, %2, %0"); 4741 #line 513 "rx-decode.opc" 4742 ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F_OSZC; 4743 4744 } 4745 break; 4746 } 4747 break; 4748 case 0x71: 4749 GETBYTE (); 4750 switch (op[1] & 0x00) 4751 { 4752 case 0x00: 4753 goto op_semantics_31; 4754 break; 4755 } 4756 break; 4757 case 0x72: 4758 GETBYTE (); 4759 switch (op[1] & 0x00) 4760 { 4761 case 0x00: 4762 goto op_semantics_31; 4763 break; 4764 } 4765 break; 4766 case 0x73: 4767 GETBYTE (); 4768 switch (op[1] & 0x00) 4769 { 4770 case 0x00: 4771 goto op_semantics_31; 4772 break; 4773 } 4774 break; 4775 case 0x74: 4776 GETBYTE (); 4777 switch (op[1] & 0xf0) 4778 { 4779 case 0x00: 4780 op_semantics_32: 4781 { 4782 /** 0111 01im 0000 rsrc cmp #%2, %1%S1 */ 4783 #line 525 "rx-decode.opc" 4784 int im AU = op[0] & 0x03; 4785 #line 525 "rx-decode.opc" 4786 int rsrc AU = op[1] & 0x0f; 4787 if (trace) 4788 { 4789 printf ("\033[33m%s\033[0m %02x %02x\n", 4790 "/** 0111 01im 0000 rsrc cmp #%2, %1%S1 */", 4791 op[0], op[1]); 4792 printf (" im = 0x%x,", im); 4793 printf (" rsrc = 0x%x\n", rsrc); 4794 } 4795 SYNTAX("cmp #%2, %1%S1"); 4796 #line 525 "rx-decode.opc" 4797 ID(sub); SR(rsrc); S2C(IMMex(im)); F_OSZC; 4798 4799 } 4800 break; 4801 case 0x10: 4802 op_semantics_33: 4803 { 4804 /** 0111 01im 0001rdst mul #%1, %0 */ 4805 #line 628 "rx-decode.opc" 4806 int im AU = op[0] & 0x03; 4807 #line 628 "rx-decode.opc" 4808 int rdst AU = op[1] & 0x0f; 4809 if (trace) 4810 { 4811 printf ("\033[33m%s\033[0m %02x %02x\n", 4812 "/** 0111 01im 0001rdst mul #%1, %0 */", 4813 op[0], op[1]); 4814 printf (" im = 0x%x,", im); 4815 printf (" rdst = 0x%x\n", rdst); 4816 } 4817 SYNTAX("mul #%1, %0"); 4818 #line 628 "rx-decode.opc" 4819 int val = IMMex(im); 4820 if (val == 1 && rdst == 0) 4821 { 4822 SYNTAX("nop\t; mul\t#1, r0"); 4823 switch (im) 4824 { 4825 case 2: ID(nop4); break; 4826 case 3: ID(nop5); break; 4827 case 0: ID(nop6); break; 4828 default: 4829 ID(mul); 4830 SYNTAX("mul #%1, %0"); 4831 break; 4832 } 4833 } 4834 else 4835 { 4836 ID(mul); 4837 } 4838 DR(rdst); SC(val); F_____; 4839 4840 } 4841 break; 4842 case 0x20: 4843 op_semantics_34: 4844 { 4845 /** 0111 01im 0010 rdst and #%1, %0 */ 4846 #line 417 "rx-decode.opc" 4847 int im AU = op[0] & 0x03; 4848 #line 417 "rx-decode.opc" 4849 int rdst AU = op[1] & 0x0f; 4850 if (trace) 4851 { 4852 printf ("\033[33m%s\033[0m %02x %02x\n", 4853 "/** 0111 01im 0010 rdst and #%1, %0 */", 4854 op[0], op[1]); 4855 printf (" im = 0x%x,", im); 4856 printf (" rdst = 0x%x\n", rdst); 4857 } 4858 SYNTAX("and #%1, %0"); 4859 #line 417 "rx-decode.opc" 4860 ID(and); SC(IMMex(im)); DR(rdst); F__SZ_; 4861 4862 } 4863 break; 4864 case 0x30: 4865 op_semantics_35: 4866 { 4867 /** 0111 01im 0011 rdst or #%1, %0 */ 4868 #line 435 "rx-decode.opc" 4869 int im AU = op[0] & 0x03; 4870 #line 435 "rx-decode.opc" 4871 int rdst AU = op[1] & 0x0f; 4872 if (trace) 4873 { 4874 printf ("\033[33m%s\033[0m %02x %02x\n", 4875 "/** 0111 01im 0011 rdst or #%1, %0 */", 4876 op[0], op[1]); 4877 printf (" im = 0x%x,", im); 4878 printf (" rdst = 0x%x\n", rdst); 4879 } 4880 SYNTAX("or #%1, %0"); 4881 #line 435 "rx-decode.opc" 4882 ID(or); SC(IMMex(im)); DR(rdst); F__SZ_; 4883 4884 } 4885 break; 4886 default: UNSUPPORTED(); break; 4887 } 4888 break; 4889 case 0x75: 4890 GETBYTE (); 4891 switch (op[1] & 0xff) 4892 { 4893 case 0x00: 4894 case 0x01: 4895 case 0x02: 4896 case 0x03: 4897 case 0x04: 4898 case 0x05: 4899 case 0x06: 4900 case 0x07: 4901 case 0x08: 4902 case 0x09: 4903 case 0x0a: 4904 case 0x0b: 4905 case 0x0c: 4906 case 0x0d: 4907 case 0x0e: 4908 case 0x0f: 4909 goto op_semantics_32; 4910 break; 4911 case 0x10: 4912 case 0x11: 4913 case 0x12: 4914 case 0x13: 4915 case 0x14: 4916 case 0x15: 4917 case 0x16: 4918 case 0x17: 4919 case 0x18: 4920 case 0x19: 4921 case 0x1a: 4922 case 0x1b: 4923 case 0x1c: 4924 case 0x1d: 4925 case 0x1e: 4926 case 0x1f: 4927 goto op_semantics_33; 4928 break; 4929 case 0x20: 4930 case 0x21: 4931 case 0x22: 4932 case 0x23: 4933 case 0x24: 4934 case 0x25: 4935 case 0x26: 4936 case 0x27: 4937 case 0x28: 4938 case 0x29: 4939 case 0x2a: 4940 case 0x2b: 4941 case 0x2c: 4942 case 0x2d: 4943 case 0x2e: 4944 case 0x2f: 4945 goto op_semantics_34; 4946 break; 4947 case 0x30: 4948 case 0x31: 4949 case 0x32: 4950 case 0x33: 4951 case 0x34: 4952 case 0x35: 4953 case 0x36: 4954 case 0x37: 4955 case 0x38: 4956 case 0x39: 4957 case 0x3a: 4958 case 0x3b: 4959 case 0x3c: 4960 case 0x3d: 4961 case 0x3e: 4962 case 0x3f: 4963 goto op_semantics_35; 4964 break; 4965 case 0x40: 4966 case 0x41: 4967 case 0x42: 4968 case 0x43: 4969 case 0x44: 4970 case 0x45: 4971 case 0x46: 4972 case 0x47: 4973 case 0x48: 4974 case 0x49: 4975 case 0x4a: 4976 case 0x4b: 4977 case 0x4c: 4978 case 0x4d: 4979 case 0x4e: 4980 case 0x4f: 4981 { 4982 /** 0111 0101 0100 rdst mov%s #%1, %0 */ 4983 #line 289 "rx-decode.opc" 4984 int rdst AU = op[1] & 0x0f; 4985 if (trace) 4986 { 4987 printf ("\033[33m%s\033[0m %02x %02x\n", 4988 "/** 0111 0101 0100 rdst mov%s #%1, %0 */", 4989 op[0], op[1]); 4990 printf (" rdst = 0x%x\n", rdst); 4991 } 4992 SYNTAX("mov%s #%1, %0"); 4993 #line 289 "rx-decode.opc" 4994 ID(mov); DR(rdst); SC(IMM (1)); F_____; 4995 4996 } 4997 break; 4998 case 0x50: 4999 case 0x51: 5000 case 0x52: 5001 case 0x53: 5002 case 0x54: 5003 case 0x55: 5004 case 0x56: 5005 case 0x57: 5006 case 0x58: 5007 case 0x59: 5008 case 0x5a: 5009 case 0x5b: 5010 case 0x5c: 5011 case 0x5d: 5012 case 0x5e: 5013 case 0x5f: 5014 { 5015 /** 0111 0101 0101 rsrc cmp #%2, %1 */ 5016 #line 528 "rx-decode.opc" 5017 int rsrc AU = op[1] & 0x0f; 5018 if (trace) 5019 { 5020 printf ("\033[33m%s\033[0m %02x %02x\n", 5021 "/** 0111 0101 0101 rsrc cmp #%2, %1 */", 5022 op[0], op[1]); 5023 printf (" rsrc = 0x%x\n", rsrc); 5024 } 5025 SYNTAX("cmp #%2, %1"); 5026 #line 528 "rx-decode.opc" 5027 ID(sub); SR(rsrc); S2C(IMM(1)); F_OSZC; 5028 5029 } 5030 break; 5031 case 0x60: 5032 { 5033 /** 0111 0101 0110 0000 int #%1 */ 5034 if (trace) 5035 { 5036 printf ("\033[33m%s\033[0m %02x %02x\n", 5037 "/** 0111 0101 0110 0000 int #%1 */", 5038 op[0], op[1]); 5039 } 5040 SYNTAX("int #%1"); 5041 #line 1035 "rx-decode.opc" 5042 ID(int); SC(IMM(1)); 5043 5044 } 5045 break; 5046 case 0x70: 5047 GETBYTE (); 5048 switch (op[2] & 0xf0) 5049 { 5050 case 0x00: 5051 { 5052 /** 0111 0101 0111 0000 0000 immm mvtipl #%1 */ 5053 #line 1002 "rx-decode.opc" 5054 int immm AU = op[2] & 0x0f; 5055 if (trace) 5056 { 5057 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 5058 "/** 0111 0101 0111 0000 0000 immm mvtipl #%1 */", 5059 op[0], op[1], op[2]); 5060 printf (" immm = 0x%x\n", immm); 5061 } 5062 SYNTAX("mvtipl #%1"); 5063 #line 1002 "rx-decode.opc" 5064 ID(mvtipl); SC(immm); 5065 5066 } 5067 break; 5068 default: UNSUPPORTED(); break; 5069 } 5070 break; 5071 default: UNSUPPORTED(); break; 5072 } 5073 break; 5074 case 0x76: 5075 GETBYTE (); 5076 switch (op[1] & 0xf0) 5077 { 5078 case 0x00: 5079 goto op_semantics_32; 5080 break; 5081 case 0x10: 5082 goto op_semantics_33; 5083 break; 5084 case 0x20: 5085 goto op_semantics_34; 5086 break; 5087 case 0x30: 5088 goto op_semantics_35; 5089 break; 5090 default: UNSUPPORTED(); break; 5091 } 5092 break; 5093 case 0x77: 5094 GETBYTE (); 5095 switch (op[1] & 0xf0) 5096 { 5097 case 0x00: 5098 goto op_semantics_32; 5099 break; 5100 case 0x10: 5101 goto op_semantics_33; 5102 break; 5103 case 0x20: 5104 goto op_semantics_34; 5105 break; 5106 case 0x30: 5107 goto op_semantics_35; 5108 break; 5109 default: UNSUPPORTED(); break; 5110 } 5111 break; 5112 case 0x78: 5113 GETBYTE (); 5114 switch (op[1] & 0x00) 5115 { 5116 case 0x00: 5117 op_semantics_36: 5118 { 5119 /** 0111 100b ittt rdst bset #%1, %0 */ 5120 #line 947 "rx-decode.opc" 5121 int b AU = op[0] & 0x01; 5122 #line 947 "rx-decode.opc" 5123 int ittt AU = (op[1] >> 4) & 0x0f; 5124 #line 947 "rx-decode.opc" 5125 int rdst AU = op[1] & 0x0f; 5126 if (trace) 5127 { 5128 printf ("\033[33m%s\033[0m %02x %02x\n", 5129 "/** 0111 100b ittt rdst bset #%1, %0 */", 5130 op[0], op[1]); 5131 printf (" b = 0x%x,", b); 5132 printf (" ittt = 0x%x,", ittt); 5133 printf (" rdst = 0x%x\n", rdst); 5134 } 5135 SYNTAX("bset #%1, %0"); 5136 #line 947 "rx-decode.opc" 5137 ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____; 5138 5139 5140 } 5141 break; 5142 } 5143 break; 5144 case 0x79: 5145 GETBYTE (); 5146 switch (op[1] & 0x00) 5147 { 5148 case 0x00: 5149 goto op_semantics_36; 5150 break; 5151 } 5152 break; 5153 case 0x7a: 5154 GETBYTE (); 5155 switch (op[1] & 0x00) 5156 { 5157 case 0x00: 5158 op_semantics_37: 5159 { 5160 /** 0111 101b ittt rdst bclr #%1, %0 */ 5161 #line 959 "rx-decode.opc" 5162 int b AU = op[0] & 0x01; 5163 #line 959 "rx-decode.opc" 5164 int ittt AU = (op[1] >> 4) & 0x0f; 5165 #line 959 "rx-decode.opc" 5166 int rdst AU = op[1] & 0x0f; 5167 if (trace) 5168 { 5169 printf ("\033[33m%s\033[0m %02x %02x\n", 5170 "/** 0111 101b ittt rdst bclr #%1, %0 */", 5171 op[0], op[1]); 5172 printf (" b = 0x%x,", b); 5173 printf (" ittt = 0x%x,", ittt); 5174 printf (" rdst = 0x%x\n", rdst); 5175 } 5176 SYNTAX("bclr #%1, %0"); 5177 #line 959 "rx-decode.opc" 5178 ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____; 5179 5180 5181 } 5182 break; 5183 } 5184 break; 5185 case 0x7b: 5186 GETBYTE (); 5187 switch (op[1] & 0x00) 5188 { 5189 case 0x00: 5190 goto op_semantics_37; 5191 break; 5192 } 5193 break; 5194 case 0x7c: 5195 GETBYTE (); 5196 switch (op[1] & 0x00) 5197 { 5198 case 0x00: 5199 op_semantics_38: 5200 { 5201 /** 0111 110b ittt rdst btst #%2, %1 */ 5202 #line 971 "rx-decode.opc" 5203 int b AU = op[0] & 0x01; 5204 #line 971 "rx-decode.opc" 5205 int ittt AU = (op[1] >> 4) & 0x0f; 5206 #line 971 "rx-decode.opc" 5207 int rdst AU = op[1] & 0x0f; 5208 if (trace) 5209 { 5210 printf ("\033[33m%s\033[0m %02x %02x\n", 5211 "/** 0111 110b ittt rdst btst #%2, %1 */", 5212 op[0], op[1]); 5213 printf (" b = 0x%x,", b); 5214 printf (" ittt = 0x%x,", ittt); 5215 printf (" rdst = 0x%x\n", rdst); 5216 } 5217 SYNTAX("btst #%2, %1"); 5218 #line 971 "rx-decode.opc" 5219 ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F___ZC; 5220 5221 5222 } 5223 break; 5224 } 5225 break; 5226 case 0x7d: 5227 GETBYTE (); 5228 switch (op[1] & 0x00) 5229 { 5230 case 0x00: 5231 goto op_semantics_38; 5232 break; 5233 } 5234 break; 5235 case 0x7e: 5236 GETBYTE (); 5237 switch (op[1] & 0xf0) 5238 { 5239 case 0x00: 5240 { 5241 /** 0111 1110 0000 rdst not %0 */ 5242 #line 462 "rx-decode.opc" 5243 int rdst AU = op[1] & 0x0f; 5244 if (trace) 5245 { 5246 printf ("\033[33m%s\033[0m %02x %02x\n", 5247 "/** 0111 1110 0000 rdst not %0 */", 5248 op[0], op[1]); 5249 printf (" rdst = 0x%x\n", rdst); 5250 } 5251 SYNTAX("not %0"); 5252 #line 462 "rx-decode.opc" 5253 ID(xor); DR(rdst); SR(rdst); S2C(~0); F__SZ_; 5254 5255 } 5256 break; 5257 case 0x10: 5258 { 5259 /** 0111 1110 0001 rdst neg %0 */ 5260 #line 483 "rx-decode.opc" 5261 int rdst AU = op[1] & 0x0f; 5262 if (trace) 5263 { 5264 printf ("\033[33m%s\033[0m %02x %02x\n", 5265 "/** 0111 1110 0001 rdst neg %0 */", 5266 op[0], op[1]); 5267 printf (" rdst = 0x%x\n", rdst); 5268 } 5269 SYNTAX("neg %0"); 5270 #line 483 "rx-decode.opc" 5271 ID(sub); DR(rdst); SC(0); S2R(rdst); F_OSZC; 5272 5273 } 5274 break; 5275 case 0x20: 5276 { 5277 /** 0111 1110 0010 rdst abs %0 */ 5278 #line 565 "rx-decode.opc" 5279 int rdst AU = op[1] & 0x0f; 5280 if (trace) 5281 { 5282 printf ("\033[33m%s\033[0m %02x %02x\n", 5283 "/** 0111 1110 0010 rdst abs %0 */", 5284 op[0], op[1]); 5285 printf (" rdst = 0x%x\n", rdst); 5286 } 5287 SYNTAX("abs %0"); 5288 #line 565 "rx-decode.opc" 5289 ID(abs); DR(rdst); SR(rdst); F_OSZ_; 5290 5291 } 5292 break; 5293 case 0x30: 5294 { 5295 /** 0111 1110 0011 rdst sat %0 */ 5296 #line 885 "rx-decode.opc" 5297 int rdst AU = op[1] & 0x0f; 5298 if (trace) 5299 { 5300 printf ("\033[33m%s\033[0m %02x %02x\n", 5301 "/** 0111 1110 0011 rdst sat %0 */", 5302 op[0], op[1]); 5303 printf (" rdst = 0x%x\n", rdst); 5304 } 5305 SYNTAX("sat %0"); 5306 #line 885 "rx-decode.opc" 5307 ID(sat); DR (rdst); 5308 5309 } 5310 break; 5311 case 0x40: 5312 { 5313 /** 0111 1110 0100 rdst rorc %0 */ 5314 #line 745 "rx-decode.opc" 5315 int rdst AU = op[1] & 0x0f; 5316 if (trace) 5317 { 5318 printf ("\033[33m%s\033[0m %02x %02x\n", 5319 "/** 0111 1110 0100 rdst rorc %0 */", 5320 op[0], op[1]); 5321 printf (" rdst = 0x%x\n", rdst); 5322 } 5323 SYNTAX("rorc %0"); 5324 #line 745 "rx-decode.opc" 5325 ID(rorc); DR(rdst); F__SZC; 5326 5327 } 5328 break; 5329 case 0x50: 5330 { 5331 /** 0111 1110 0101 rdst rolc %0 */ 5332 #line 742 "rx-decode.opc" 5333 int rdst AU = op[1] & 0x0f; 5334 if (trace) 5335 { 5336 printf ("\033[33m%s\033[0m %02x %02x\n", 5337 "/** 0111 1110 0101 rdst rolc %0 */", 5338 op[0], op[1]); 5339 printf (" rdst = 0x%x\n", rdst); 5340 } 5341 SYNTAX("rolc %0"); 5342 #line 742 "rx-decode.opc" 5343 ID(rolc); DR(rdst); F__SZC; 5344 5345 } 5346 break; 5347 case 0x80: 5348 case 0x90: 5349 case 0xa0: 5350 { 5351 /** 0111 1110 10sz rsrc push%s %1 */ 5352 #line 378 "rx-decode.opc" 5353 int sz AU = (op[1] >> 4) & 0x03; 5354 #line 378 "rx-decode.opc" 5355 int rsrc AU = op[1] & 0x0f; 5356 if (trace) 5357 { 5358 printf ("\033[33m%s\033[0m %02x %02x\n", 5359 "/** 0111 1110 10sz rsrc push%s %1 */", 5360 op[0], op[1]); 5361 printf (" sz = 0x%x,", sz); 5362 printf (" rsrc = 0x%x\n", rsrc); 5363 } 5364 SYNTAX("push%s %1"); 5365 #line 378 "rx-decode.opc" 5366 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F_____; 5367 5368 } 5369 break; 5370 case 0xb0: 5371 { 5372 /** 0111 1110 1011 rdst pop %0 */ 5373 #line 375 "rx-decode.opc" 5374 int rdst AU = op[1] & 0x0f; 5375 if (trace) 5376 { 5377 printf ("\033[33m%s\033[0m %02x %02x\n", 5378 "/** 0111 1110 1011 rdst pop %0 */", 5379 op[0], op[1]); 5380 printf (" rdst = 0x%x\n", rdst); 5381 } 5382 SYNTAX("pop %0"); 5383 #line 375 "rx-decode.opc" 5384 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F_____; 5385 5386 } 5387 break; 5388 case 0xc0: 5389 case 0xd0: 5390 { 5391 /** 0111 1110 110 crsrc pushc %1 */ 5392 #line 1008 "rx-decode.opc" 5393 int crsrc AU = op[1] & 0x1f; 5394 if (trace) 5395 { 5396 printf ("\033[33m%s\033[0m %02x %02x\n", 5397 "/** 0111 1110 110 crsrc pushc %1 */", 5398 op[0], op[1]); 5399 printf (" crsrc = 0x%x\n", crsrc); 5400 } 5401 SYNTAX("pushc %1"); 5402 #line 1008 "rx-decode.opc" 5403 ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16); 5404 5405 } 5406 break; 5407 case 0xe0: 5408 case 0xf0: 5409 { 5410 /** 0111 1110 111 crdst popc %0 */ 5411 #line 1005 "rx-decode.opc" 5412 int crdst AU = op[1] & 0x1f; 5413 if (trace) 5414 { 5415 printf ("\033[33m%s\033[0m %02x %02x\n", 5416 "/** 0111 1110 111 crdst popc %0 */", 5417 op[0], op[1]); 5418 printf (" crdst = 0x%x\n", crdst); 5419 } 5420 SYNTAX("popc %0"); 5421 #line 1005 "rx-decode.opc" 5422 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16); 5423 5424 } 5425 break; 5426 default: UNSUPPORTED(); break; 5427 } 5428 break; 5429 case 0x7f: 5430 GETBYTE (); 5431 switch (op[1] & 0xff) 5432 { 5433 case 0x00: 5434 case 0x01: 5435 case 0x02: 5436 case 0x03: 5437 case 0x04: 5438 case 0x05: 5439 case 0x06: 5440 case 0x07: 5441 case 0x08: 5442 case 0x09: 5443 case 0x0a: 5444 case 0x0b: 5445 case 0x0c: 5446 case 0x0d: 5447 case 0x0e: 5448 case 0x0f: 5449 { 5450 /** 0111 1111 0000 rsrc jmp %0 */ 5451 #line 795 "rx-decode.opc" 5452 int rsrc AU = op[1] & 0x0f; 5453 if (trace) 5454 { 5455 printf ("\033[33m%s\033[0m %02x %02x\n", 5456 "/** 0111 1111 0000 rsrc jmp %0 */", 5457 op[0], op[1]); 5458 printf (" rsrc = 0x%x\n", rsrc); 5459 } 5460 SYNTAX("jmp %0"); 5461 #line 795 "rx-decode.opc" 5462 ID(branch); DR(rsrc); 5463 5464 } 5465 break; 5466 case 0x10: 5467 case 0x11: 5468 case 0x12: 5469 case 0x13: 5470 case 0x14: 5471 case 0x15: 5472 case 0x16: 5473 case 0x17: 5474 case 0x18: 5475 case 0x19: 5476 case 0x1a: 5477 case 0x1b: 5478 case 0x1c: 5479 case 0x1d: 5480 case 0x1e: 5481 case 0x1f: 5482 { 5483 /** 0111 1111 0001 rsrc jsr %0 */ 5484 #line 798 "rx-decode.opc" 5485 int rsrc AU = op[1] & 0x0f; 5486 if (trace) 5487 { 5488 printf ("\033[33m%s\033[0m %02x %02x\n", 5489 "/** 0111 1111 0001 rsrc jsr %0 */", 5490 op[0], op[1]); 5491 printf (" rsrc = 0x%x\n", rsrc); 5492 } 5493 SYNTAX("jsr %0"); 5494 #line 798 "rx-decode.opc" 5495 ID(jsr); DR(rsrc); 5496 5497 } 5498 break; 5499 case 0x40: 5500 case 0x41: 5501 case 0x42: 5502 case 0x43: 5503 case 0x44: 5504 case 0x45: 5505 case 0x46: 5506 case 0x47: 5507 case 0x48: 5508 case 0x49: 5509 case 0x4a: 5510 case 0x4b: 5511 case 0x4c: 5512 case 0x4d: 5513 case 0x4e: 5514 case 0x4f: 5515 { 5516 /** 0111 1111 0100 rsrc bra.l %0 */ 5517 #line 791 "rx-decode.opc" 5518 int rsrc AU = op[1] & 0x0f; 5519 if (trace) 5520 { 5521 printf ("\033[33m%s\033[0m %02x %02x\n", 5522 "/** 0111 1111 0100 rsrc bra.l %0 */", 5523 op[0], op[1]); 5524 printf (" rsrc = 0x%x\n", rsrc); 5525 } 5526 SYNTAX("bra.l %0"); 5527 #line 791 "rx-decode.opc" 5528 ID(branchrel); DR(rsrc); 5529 5530 5531 } 5532 break; 5533 case 0x50: 5534 case 0x51: 5535 case 0x52: 5536 case 0x53: 5537 case 0x54: 5538 case 0x55: 5539 case 0x56: 5540 case 0x57: 5541 case 0x58: 5542 case 0x59: 5543 case 0x5a: 5544 case 0x5b: 5545 case 0x5c: 5546 case 0x5d: 5547 case 0x5e: 5548 case 0x5f: 5549 { 5550 /** 0111 1111 0101 rsrc bsr.l %0 */ 5551 #line 807 "rx-decode.opc" 5552 int rsrc AU = op[1] & 0x0f; 5553 if (trace) 5554 { 5555 printf ("\033[33m%s\033[0m %02x %02x\n", 5556 "/** 0111 1111 0101 rsrc bsr.l %0 */", 5557 op[0], op[1]); 5558 printf (" rsrc = 0x%x\n", rsrc); 5559 } 5560 SYNTAX("bsr.l %0"); 5561 #line 807 "rx-decode.opc" 5562 ID(jsrrel); DR(rsrc); 5563 5564 } 5565 break; 5566 case 0x80: 5567 case 0x81: 5568 case 0x82: 5569 { 5570 /** 0111 1111 1000 00sz suntil%s */ 5571 #line 831 "rx-decode.opc" 5572 int sz AU = op[1] & 0x03; 5573 if (trace) 5574 { 5575 printf ("\033[33m%s\033[0m %02x %02x\n", 5576 "/** 0111 1111 1000 00sz suntil%s */", 5577 op[0], op[1]); 5578 printf (" sz = 0x%x\n", sz); 5579 } 5580 SYNTAX("suntil%s"); 5581 #line 831 "rx-decode.opc" 5582 ID(suntil); BWL(sz); F___ZC; 5583 5584 } 5585 break; 5586 case 0x83: 5587 { 5588 /** 0111 1111 1000 0011 scmpu */ 5589 if (trace) 5590 { 5591 printf ("\033[33m%s\033[0m %02x %02x\n", 5592 "/** 0111 1111 1000 0011 scmpu */", 5593 op[0], op[1]); 5594 } 5595 SYNTAX("scmpu"); 5596 #line 822 "rx-decode.opc" 5597 ID(scmpu); F___ZC; 5598 5599 } 5600 break; 5601 case 0x84: 5602 case 0x85: 5603 case 0x86: 5604 { 5605 /** 0111 1111 1000 01sz swhile%s */ 5606 #line 834 "rx-decode.opc" 5607 int sz AU = op[1] & 0x03; 5608 if (trace) 5609 { 5610 printf ("\033[33m%s\033[0m %02x %02x\n", 5611 "/** 0111 1111 1000 01sz swhile%s */", 5612 op[0], op[1]); 5613 printf (" sz = 0x%x\n", sz); 5614 } 5615 SYNTAX("swhile%s"); 5616 #line 834 "rx-decode.opc" 5617 ID(swhile); BWL(sz); F___ZC; 5618 5619 } 5620 break; 5621 case 0x87: 5622 { 5623 /** 0111 1111 1000 0111 smovu */ 5624 if (trace) 5625 { 5626 printf ("\033[33m%s\033[0m %02x %02x\n", 5627 "/** 0111 1111 1000 0111 smovu */", 5628 op[0], op[1]); 5629 } 5630 SYNTAX("smovu"); 5631 #line 825 "rx-decode.opc" 5632 ID(smovu); 5633 5634 } 5635 break; 5636 case 0x88: 5637 case 0x89: 5638 case 0x8a: 5639 { 5640 /** 0111 1111 1000 10sz sstr%s */ 5641 #line 840 "rx-decode.opc" 5642 int sz AU = op[1] & 0x03; 5643 if (trace) 5644 { 5645 printf ("\033[33m%s\033[0m %02x %02x\n", 5646 "/** 0111 1111 1000 10sz sstr%s */", 5647 op[0], op[1]); 5648 printf (" sz = 0x%x\n", sz); 5649 } 5650 SYNTAX("sstr%s"); 5651 #line 840 "rx-decode.opc" 5652 ID(sstr); BWL(sz); 5653 5654 /*----------------------------------------------------------------------*/ 5655 /* RMPA */ 5656 5657 } 5658 break; 5659 case 0x8b: 5660 { 5661 /** 0111 1111 1000 1011 smovb */ 5662 if (trace) 5663 { 5664 printf ("\033[33m%s\033[0m %02x %02x\n", 5665 "/** 0111 1111 1000 1011 smovb */", 5666 op[0], op[1]); 5667 } 5668 SYNTAX("smovb"); 5669 #line 828 "rx-decode.opc" 5670 ID(smovb); 5671 5672 } 5673 break; 5674 case 0x8c: 5675 case 0x8d: 5676 case 0x8e: 5677 { 5678 /** 0111 1111 1000 11sz rmpa%s */ 5679 #line 846 "rx-decode.opc" 5680 int sz AU = op[1] & 0x03; 5681 if (trace) 5682 { 5683 printf ("\033[33m%s\033[0m %02x %02x\n", 5684 "/** 0111 1111 1000 11sz rmpa%s */", 5685 op[0], op[1]); 5686 printf (" sz = 0x%x\n", sz); 5687 } 5688 SYNTAX("rmpa%s"); 5689 #line 846 "rx-decode.opc" 5690 ID(rmpa); BWL(sz); F_OS__; 5691 5692 /*----------------------------------------------------------------------*/ 5693 /* HI/LO stuff */ 5694 5695 } 5696 break; 5697 case 0x8f: 5698 { 5699 /** 0111 1111 1000 1111 smovf */ 5700 if (trace) 5701 { 5702 printf ("\033[33m%s\033[0m %02x %02x\n", 5703 "/** 0111 1111 1000 1111 smovf */", 5704 op[0], op[1]); 5705 } 5706 SYNTAX("smovf"); 5707 #line 837 "rx-decode.opc" 5708 ID(smovf); 5709 5710 } 5711 break; 5712 case 0x93: 5713 { 5714 /** 0111 1111 1001 0011 satr */ 5715 if (trace) 5716 { 5717 printf ("\033[33m%s\033[0m %02x %02x\n", 5718 "/** 0111 1111 1001 0011 satr */", 5719 op[0], op[1]); 5720 } 5721 SYNTAX("satr"); 5722 #line 888 "rx-decode.opc" 5723 ID(satr); 5724 5725 /*----------------------------------------------------------------------*/ 5726 /* FLOAT */ 5727 5728 } 5729 break; 5730 case 0x94: 5731 { 5732 /** 0111 1111 1001 0100 rtfi */ 5733 if (trace) 5734 { 5735 printf ("\033[33m%s\033[0m %02x %02x\n", 5736 "/** 0111 1111 1001 0100 rtfi */", 5737 op[0], op[1]); 5738 } 5739 SYNTAX("rtfi"); 5740 #line 1023 "rx-decode.opc" 5741 ID(rtfi); 5742 5743 } 5744 break; 5745 case 0x95: 5746 { 5747 /** 0111 1111 1001 0101 rte */ 5748 if (trace) 5749 { 5750 printf ("\033[33m%s\033[0m %02x %02x\n", 5751 "/** 0111 1111 1001 0101 rte */", 5752 op[0], op[1]); 5753 } 5754 SYNTAX("rte"); 5755 #line 1026 "rx-decode.opc" 5756 ID(rte); 5757 5758 } 5759 break; 5760 case 0x96: 5761 { 5762 /** 0111 1111 1001 0110 wait */ 5763 if (trace) 5764 { 5765 printf ("\033[33m%s\033[0m %02x %02x\n", 5766 "/** 0111 1111 1001 0110 wait */", 5767 op[0], op[1]); 5768 } 5769 SYNTAX("wait"); 5770 #line 1038 "rx-decode.opc" 5771 ID(wait); 5772 5773 /*----------------------------------------------------------------------*/ 5774 /* SCcnd */ 5775 5776 } 5777 break; 5778 case 0xa0: 5779 case 0xa1: 5780 case 0xa2: 5781 case 0xa3: 5782 case 0xa4: 5783 case 0xa5: 5784 case 0xa6: 5785 case 0xa7: 5786 case 0xa8: 5787 case 0xa9: 5788 case 0xaa: 5789 case 0xab: 5790 case 0xac: 5791 case 0xad: 5792 case 0xae: 5793 case 0xaf: 5794 { 5795 /** 0111 1111 1010 rdst setpsw %0 */ 5796 #line 999 "rx-decode.opc" 5797 int rdst AU = op[1] & 0x0f; 5798 if (trace) 5799 { 5800 printf ("\033[33m%s\033[0m %02x %02x\n", 5801 "/** 0111 1111 1010 rdst setpsw %0 */", 5802 op[0], op[1]); 5803 printf (" rdst = 0x%x\n", rdst); 5804 } 5805 SYNTAX("setpsw %0"); 5806 #line 999 "rx-decode.opc" 5807 ID(setpsw); DF(rdst); 5808 5809 } 5810 break; 5811 case 0xb0: 5812 case 0xb1: 5813 case 0xb2: 5814 case 0xb3: 5815 case 0xb4: 5816 case 0xb5: 5817 case 0xb6: 5818 case 0xb7: 5819 case 0xb8: 5820 case 0xb9: 5821 case 0xba: 5822 case 0xbb: 5823 case 0xbc: 5824 case 0xbd: 5825 case 0xbe: 5826 case 0xbf: 5827 { 5828 /** 0111 1111 1011 rdst clrpsw %0 */ 5829 #line 996 "rx-decode.opc" 5830 int rdst AU = op[1] & 0x0f; 5831 if (trace) 5832 { 5833 printf ("\033[33m%s\033[0m %02x %02x\n", 5834 "/** 0111 1111 1011 rdst clrpsw %0 */", 5835 op[0], op[1]); 5836 printf (" rdst = 0x%x\n", rdst); 5837 } 5838 SYNTAX("clrpsw %0"); 5839 #line 996 "rx-decode.opc" 5840 ID(clrpsw); DF(rdst); 5841 5842 } 5843 break; 5844 default: UNSUPPORTED(); break; 5845 } 5846 break; 5847 case 0x80: 5848 GETBYTE (); 5849 switch (op[1] & 0x00) 5850 { 5851 case 0x00: 5852 op_semantics_39: 5853 { 5854 /** 10sz 0dsp a dst b src mov%s %1, %0 */ 5855 #line 336 "rx-decode.opc" 5856 int sz AU = (op[0] >> 4) & 0x03; 5857 #line 336 "rx-decode.opc" 5858 int dsp AU = op[0] & 0x07; 5859 #line 336 "rx-decode.opc" 5860 int a AU = (op[1] >> 7) & 0x01; 5861 #line 336 "rx-decode.opc" 5862 int dst AU = (op[1] >> 4) & 0x07; 5863 #line 336 "rx-decode.opc" 5864 int b AU = (op[1] >> 3) & 0x01; 5865 #line 336 "rx-decode.opc" 5866 int src AU = op[1] & 0x07; 5867 if (trace) 5868 { 5869 printf ("\033[33m%s\033[0m %02x %02x\n", 5870 "/** 10sz 0dsp a dst b src mov%s %1, %0 */", 5871 op[0], op[1]); 5872 printf (" sz = 0x%x,", sz); 5873 printf (" dsp = 0x%x,", dsp); 5874 printf (" a = 0x%x,", a); 5875 printf (" dst = 0x%x,", dst); 5876 printf (" b = 0x%x,", b); 5877 printf (" src = 0x%x\n", src); 5878 } 5879 SYNTAX("mov%s %1, %0"); 5880 #line 336 "rx-decode.opc" 5881 ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F_____; 5882 5883 } 5884 break; 5885 } 5886 break; 5887 case 0x81: 5888 GETBYTE (); 5889 switch (op[1] & 0x00) 5890 { 5891 case 0x00: 5892 goto op_semantics_39; 5893 break; 5894 } 5895 break; 5896 case 0x82: 5897 GETBYTE (); 5898 switch (op[1] & 0x00) 5899 { 5900 case 0x00: 5901 goto op_semantics_39; 5902 break; 5903 } 5904 break; 5905 case 0x83: 5906 GETBYTE (); 5907 switch (op[1] & 0x00) 5908 { 5909 case 0x00: 5910 goto op_semantics_39; 5911 break; 5912 } 5913 break; 5914 case 0x84: 5915 GETBYTE (); 5916 switch (op[1] & 0x00) 5917 { 5918 case 0x00: 5919 goto op_semantics_39; 5920 break; 5921 } 5922 break; 5923 case 0x85: 5924 GETBYTE (); 5925 switch (op[1] & 0x00) 5926 { 5927 case 0x00: 5928 goto op_semantics_39; 5929 break; 5930 } 5931 break; 5932 case 0x86: 5933 GETBYTE (); 5934 switch (op[1] & 0x00) 5935 { 5936 case 0x00: 5937 goto op_semantics_39; 5938 break; 5939 } 5940 break; 5941 case 0x87: 5942 GETBYTE (); 5943 switch (op[1] & 0x00) 5944 { 5945 case 0x00: 5946 goto op_semantics_39; 5947 break; 5948 } 5949 break; 5950 case 0x88: 5951 GETBYTE (); 5952 switch (op[1] & 0x00) 5953 { 5954 case 0x00: 5955 op_semantics_40: 5956 { 5957 /** 10sz 1dsp a src b dst mov%s %1, %0 */ 5958 #line 333 "rx-decode.opc" 5959 int sz AU = (op[0] >> 4) & 0x03; 5960 #line 333 "rx-decode.opc" 5961 int dsp AU = op[0] & 0x07; 5962 #line 333 "rx-decode.opc" 5963 int a AU = (op[1] >> 7) & 0x01; 5964 #line 333 "rx-decode.opc" 5965 int src AU = (op[1] >> 4) & 0x07; 5966 #line 333 "rx-decode.opc" 5967 int b AU = (op[1] >> 3) & 0x01; 5968 #line 333 "rx-decode.opc" 5969 int dst AU = op[1] & 0x07; 5970 if (trace) 5971 { 5972 printf ("\033[33m%s\033[0m %02x %02x\n", 5973 "/** 10sz 1dsp a src b dst mov%s %1, %0 */", 5974 op[0], op[1]); 5975 printf (" sz = 0x%x,", sz); 5976 printf (" dsp = 0x%x,", dsp); 5977 printf (" a = 0x%x,", a); 5978 printf (" src = 0x%x,", src); 5979 printf (" b = 0x%x,", b); 5980 printf (" dst = 0x%x\n", dst); 5981 } 5982 SYNTAX("mov%s %1, %0"); 5983 #line 333 "rx-decode.opc" 5984 ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F_____; 5985 5986 } 5987 break; 5988 } 5989 break; 5990 case 0x89: 5991 GETBYTE (); 5992 switch (op[1] & 0x00) 5993 { 5994 case 0x00: 5995 goto op_semantics_40; 5996 break; 5997 } 5998 break; 5999 case 0x8a: 6000 GETBYTE (); 6001 switch (op[1] & 0x00) 6002 { 6003 case 0x00: 6004 goto op_semantics_40; 6005 break; 6006 } 6007 break; 6008 case 0x8b: 6009 GETBYTE (); 6010 switch (op[1] & 0x00) 6011 { 6012 case 0x00: 6013 goto op_semantics_40; 6014 break; 6015 } 6016 break; 6017 case 0x8c: 6018 GETBYTE (); 6019 switch (op[1] & 0x00) 6020 { 6021 case 0x00: 6022 goto op_semantics_40; 6023 break; 6024 } 6025 break; 6026 case 0x8d: 6027 GETBYTE (); 6028 switch (op[1] & 0x00) 6029 { 6030 case 0x00: 6031 goto op_semantics_40; 6032 break; 6033 } 6034 break; 6035 case 0x8e: 6036 GETBYTE (); 6037 switch (op[1] & 0x00) 6038 { 6039 case 0x00: 6040 goto op_semantics_40; 6041 break; 6042 } 6043 break; 6044 case 0x8f: 6045 GETBYTE (); 6046 switch (op[1] & 0x00) 6047 { 6048 case 0x00: 6049 goto op_semantics_40; 6050 break; 6051 } 6052 break; 6053 case 0x90: 6054 GETBYTE (); 6055 switch (op[1] & 0x00) 6056 { 6057 case 0x00: 6058 goto op_semantics_39; 6059 break; 6060 } 6061 break; 6062 case 0x91: 6063 GETBYTE (); 6064 switch (op[1] & 0x00) 6065 { 6066 case 0x00: 6067 goto op_semantics_39; 6068 break; 6069 } 6070 break; 6071 case 0x92: 6072 GETBYTE (); 6073 switch (op[1] & 0x00) 6074 { 6075 case 0x00: 6076 goto op_semantics_39; 6077 break; 6078 } 6079 break; 6080 case 0x93: 6081 GETBYTE (); 6082 switch (op[1] & 0x00) 6083 { 6084 case 0x00: 6085 goto op_semantics_39; 6086 break; 6087 } 6088 break; 6089 case 0x94: 6090 GETBYTE (); 6091 switch (op[1] & 0x00) 6092 { 6093 case 0x00: 6094 goto op_semantics_39; 6095 break; 6096 } 6097 break; 6098 case 0x95: 6099 GETBYTE (); 6100 switch (op[1] & 0x00) 6101 { 6102 case 0x00: 6103 goto op_semantics_39; 6104 break; 6105 } 6106 break; 6107 case 0x96: 6108 GETBYTE (); 6109 switch (op[1] & 0x00) 6110 { 6111 case 0x00: 6112 goto op_semantics_39; 6113 break; 6114 } 6115 break; 6116 case 0x97: 6117 GETBYTE (); 6118 switch (op[1] & 0x00) 6119 { 6120 case 0x00: 6121 goto op_semantics_39; 6122 break; 6123 } 6124 break; 6125 case 0x98: 6126 GETBYTE (); 6127 switch (op[1] & 0x00) 6128 { 6129 case 0x00: 6130 goto op_semantics_40; 6131 break; 6132 } 6133 break; 6134 case 0x99: 6135 GETBYTE (); 6136 switch (op[1] & 0x00) 6137 { 6138 case 0x00: 6139 goto op_semantics_40; 6140 break; 6141 } 6142 break; 6143 case 0x9a: 6144 GETBYTE (); 6145 switch (op[1] & 0x00) 6146 { 6147 case 0x00: 6148 goto op_semantics_40; 6149 break; 6150 } 6151 break; 6152 case 0x9b: 6153 GETBYTE (); 6154 switch (op[1] & 0x00) 6155 { 6156 case 0x00: 6157 goto op_semantics_40; 6158 break; 6159 } 6160 break; 6161 case 0x9c: 6162 GETBYTE (); 6163 switch (op[1] & 0x00) 6164 { 6165 case 0x00: 6166 goto op_semantics_40; 6167 break; 6168 } 6169 break; 6170 case 0x9d: 6171 GETBYTE (); 6172 switch (op[1] & 0x00) 6173 { 6174 case 0x00: 6175 goto op_semantics_40; 6176 break; 6177 } 6178 break; 6179 case 0x9e: 6180 GETBYTE (); 6181 switch (op[1] & 0x00) 6182 { 6183 case 0x00: 6184 goto op_semantics_40; 6185 break; 6186 } 6187 break; 6188 case 0x9f: 6189 GETBYTE (); 6190 switch (op[1] & 0x00) 6191 { 6192 case 0x00: 6193 goto op_semantics_40; 6194 break; 6195 } 6196 break; 6197 case 0xa0: 6198 GETBYTE (); 6199 switch (op[1] & 0x00) 6200 { 6201 case 0x00: 6202 goto op_semantics_39; 6203 break; 6204 } 6205 break; 6206 case 0xa1: 6207 GETBYTE (); 6208 switch (op[1] & 0x00) 6209 { 6210 case 0x00: 6211 goto op_semantics_39; 6212 break; 6213 } 6214 break; 6215 case 0xa2: 6216 GETBYTE (); 6217 switch (op[1] & 0x00) 6218 { 6219 case 0x00: 6220 goto op_semantics_39; 6221 break; 6222 } 6223 break; 6224 case 0xa3: 6225 GETBYTE (); 6226 switch (op[1] & 0x00) 6227 { 6228 case 0x00: 6229 goto op_semantics_39; 6230 break; 6231 } 6232 break; 6233 case 0xa4: 6234 GETBYTE (); 6235 switch (op[1] & 0x00) 6236 { 6237 case 0x00: 6238 goto op_semantics_39; 6239 break; 6240 } 6241 break; 6242 case 0xa5: 6243 GETBYTE (); 6244 switch (op[1] & 0x00) 6245 { 6246 case 0x00: 6247 goto op_semantics_39; 6248 break; 6249 } 6250 break; 6251 case 0xa6: 6252 GETBYTE (); 6253 switch (op[1] & 0x00) 6254 { 6255 case 0x00: 6256 goto op_semantics_39; 6257 break; 6258 } 6259 break; 6260 case 0xa7: 6261 GETBYTE (); 6262 switch (op[1] & 0x00) 6263 { 6264 case 0x00: 6265 goto op_semantics_39; 6266 break; 6267 } 6268 break; 6269 case 0xa8: 6270 GETBYTE (); 6271 switch (op[1] & 0x00) 6272 { 6273 case 0x00: 6274 goto op_semantics_40; 6275 break; 6276 } 6277 break; 6278 case 0xa9: 6279 GETBYTE (); 6280 switch (op[1] & 0x00) 6281 { 6282 case 0x00: 6283 goto op_semantics_40; 6284 break; 6285 } 6286 break; 6287 case 0xaa: 6288 GETBYTE (); 6289 switch (op[1] & 0x00) 6290 { 6291 case 0x00: 6292 goto op_semantics_40; 6293 break; 6294 } 6295 break; 6296 case 0xab: 6297 GETBYTE (); 6298 switch (op[1] & 0x00) 6299 { 6300 case 0x00: 6301 goto op_semantics_40; 6302 break; 6303 } 6304 break; 6305 case 0xac: 6306 GETBYTE (); 6307 switch (op[1] & 0x00) 6308 { 6309 case 0x00: 6310 goto op_semantics_40; 6311 break; 6312 } 6313 break; 6314 case 0xad: 6315 GETBYTE (); 6316 switch (op[1] & 0x00) 6317 { 6318 case 0x00: 6319 goto op_semantics_40; 6320 break; 6321 } 6322 break; 6323 case 0xae: 6324 GETBYTE (); 6325 switch (op[1] & 0x00) 6326 { 6327 case 0x00: 6328 goto op_semantics_40; 6329 break; 6330 } 6331 break; 6332 case 0xaf: 6333 GETBYTE (); 6334 switch (op[1] & 0x00) 6335 { 6336 case 0x00: 6337 goto op_semantics_40; 6338 break; 6339 } 6340 break; 6341 case 0xb0: 6342 GETBYTE (); 6343 switch (op[1] & 0x00) 6344 { 6345 case 0x00: 6346 op_semantics_41: 6347 { 6348 /** 1011 w dsp a src b dst movu%s %1, %0 */ 6349 #line 356 "rx-decode.opc" 6350 int w AU = (op[0] >> 3) & 0x01; 6351 #line 356 "rx-decode.opc" 6352 int dsp AU = op[0] & 0x07; 6353 #line 356 "rx-decode.opc" 6354 int a AU = (op[1] >> 7) & 0x01; 6355 #line 356 "rx-decode.opc" 6356 int src AU = (op[1] >> 4) & 0x07; 6357 #line 356 "rx-decode.opc" 6358 int b AU = (op[1] >> 3) & 0x01; 6359 #line 356 "rx-decode.opc" 6360 int dst AU = op[1] & 0x07; 6361 if (trace) 6362 { 6363 printf ("\033[33m%s\033[0m %02x %02x\n", 6364 "/** 1011 w dsp a src b dst movu%s %1, %0 */", 6365 op[0], op[1]); 6366 printf (" w = 0x%x,", w); 6367 printf (" dsp = 0x%x,", dsp); 6368 printf (" a = 0x%x,", a); 6369 printf (" src = 0x%x,", src); 6370 printf (" b = 0x%x,", b); 6371 printf (" dst = 0x%x\n", dst); 6372 } 6373 SYNTAX("movu%s %1, %0"); 6374 #line 356 "rx-decode.opc" 6375 ID(mov); uBW(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F_____; 6376 6377 } 6378 break; 6379 } 6380 break; 6381 case 0xb1: 6382 GETBYTE (); 6383 switch (op[1] & 0x00) 6384 { 6385 case 0x00: 6386 goto op_semantics_41; 6387 break; 6388 } 6389 break; 6390 case 0xb2: 6391 GETBYTE (); 6392 switch (op[1] & 0x00) 6393 { 6394 case 0x00: 6395 goto op_semantics_41; 6396 break; 6397 } 6398 break; 6399 case 0xb3: 6400 GETBYTE (); 6401 switch (op[1] & 0x00) 6402 { 6403 case 0x00: 6404 goto op_semantics_41; 6405 break; 6406 } 6407 break; 6408 case 0xb4: 6409 GETBYTE (); 6410 switch (op[1] & 0x00) 6411 { 6412 case 0x00: 6413 goto op_semantics_41; 6414 break; 6415 } 6416 break; 6417 case 0xb5: 6418 GETBYTE (); 6419 switch (op[1] & 0x00) 6420 { 6421 case 0x00: 6422 goto op_semantics_41; 6423 break; 6424 } 6425 break; 6426 case 0xb6: 6427 GETBYTE (); 6428 switch (op[1] & 0x00) 6429 { 6430 case 0x00: 6431 goto op_semantics_41; 6432 break; 6433 } 6434 break; 6435 case 0xb7: 6436 GETBYTE (); 6437 switch (op[1] & 0x00) 6438 { 6439 case 0x00: 6440 goto op_semantics_41; 6441 break; 6442 } 6443 break; 6444 case 0xb8: 6445 GETBYTE (); 6446 switch (op[1] & 0x00) 6447 { 6448 case 0x00: 6449 goto op_semantics_41; 6450 break; 6451 } 6452 break; 6453 case 0xb9: 6454 GETBYTE (); 6455 switch (op[1] & 0x00) 6456 { 6457 case 0x00: 6458 goto op_semantics_41; 6459 break; 6460 } 6461 break; 6462 case 0xba: 6463 GETBYTE (); 6464 switch (op[1] & 0x00) 6465 { 6466 case 0x00: 6467 goto op_semantics_41; 6468 break; 6469 } 6470 break; 6471 case 0xbb: 6472 GETBYTE (); 6473 switch (op[1] & 0x00) 6474 { 6475 case 0x00: 6476 goto op_semantics_41; 6477 break; 6478 } 6479 break; 6480 case 0xbc: 6481 GETBYTE (); 6482 switch (op[1] & 0x00) 6483 { 6484 case 0x00: 6485 goto op_semantics_41; 6486 break; 6487 } 6488 break; 6489 case 0xbd: 6490 GETBYTE (); 6491 switch (op[1] & 0x00) 6492 { 6493 case 0x00: 6494 goto op_semantics_41; 6495 break; 6496 } 6497 break; 6498 case 0xbe: 6499 GETBYTE (); 6500 switch (op[1] & 0x00) 6501 { 6502 case 0x00: 6503 goto op_semantics_41; 6504 break; 6505 } 6506 break; 6507 case 0xbf: 6508 GETBYTE (); 6509 switch (op[1] & 0x00) 6510 { 6511 case 0x00: 6512 goto op_semantics_41; 6513 break; 6514 } 6515 break; 6516 case 0xc0: 6517 GETBYTE (); 6518 switch (op[1] & 0x00) 6519 { 6520 case 0x00: 6521 op_semantics_42: 6522 { 6523 /** 11sz sd ss rsrc rdst mov%s %1, %0 */ 6524 #line 314 "rx-decode.opc" 6525 int sz AU = (op[0] >> 4) & 0x03; 6526 #line 314 "rx-decode.opc" 6527 int sd AU = (op[0] >> 2) & 0x03; 6528 #line 314 "rx-decode.opc" 6529 int ss AU = op[0] & 0x03; 6530 #line 314 "rx-decode.opc" 6531 int rsrc AU = (op[1] >> 4) & 0x0f; 6532 #line 314 "rx-decode.opc" 6533 int rdst AU = op[1] & 0x0f; 6534 if (trace) 6535 { 6536 printf ("\033[33m%s\033[0m %02x %02x\n", 6537 "/** 11sz sd ss rsrc rdst mov%s %1, %0 */", 6538 op[0], op[1]); 6539 printf (" sz = 0x%x,", sz); 6540 printf (" sd = 0x%x,", sd); 6541 printf (" ss = 0x%x,", ss); 6542 printf (" rsrc = 0x%x,", rsrc); 6543 printf (" rdst = 0x%x\n", rdst); 6544 } 6545 SYNTAX("mov%s %1, %0"); 6546 #line 314 "rx-decode.opc" 6547 if (sd == 3 && ss == 3 && sz == 2 && rsrc == 0 && rdst == 0) 6548 { 6549 ID(nop2); 6550 SYNTAX ("nop\t; mov.l\tr0, r0"); 6551 } 6552 else 6553 { 6554 ID(mov); sBWL(sz); F_____; 6555 if ((ss == 3) && (sd != 3)) 6556 { 6557 SD(ss, rdst, sz); DD(sd, rsrc, sz); 6558 } 6559 else 6560 { 6561 SD(ss, rsrc, sz); DD(sd, rdst, sz); 6562 } 6563 } 6564 6565 } 6566 break; 6567 } 6568 break; 6569 case 0xc1: 6570 GETBYTE (); 6571 switch (op[1] & 0x00) 6572 { 6573 case 0x00: 6574 goto op_semantics_42; 6575 break; 6576 } 6577 break; 6578 case 0xc2: 6579 GETBYTE (); 6580 switch (op[1] & 0x00) 6581 { 6582 case 0x00: 6583 goto op_semantics_42; 6584 break; 6585 } 6586 break; 6587 case 0xc3: 6588 GETBYTE (); 6589 switch (op[1] & 0x00) 6590 { 6591 case 0x00: 6592 goto op_semantics_42; 6593 break; 6594 } 6595 break; 6596 case 0xc4: 6597 GETBYTE (); 6598 switch (op[1] & 0x00) 6599 { 6600 case 0x00: 6601 goto op_semantics_42; 6602 break; 6603 } 6604 break; 6605 case 0xc5: 6606 GETBYTE (); 6607 switch (op[1] & 0x00) 6608 { 6609 case 0x00: 6610 goto op_semantics_42; 6611 break; 6612 } 6613 break; 6614 case 0xc6: 6615 GETBYTE (); 6616 switch (op[1] & 0x00) 6617 { 6618 case 0x00: 6619 goto op_semantics_42; 6620 break; 6621 } 6622 break; 6623 case 0xc7: 6624 GETBYTE (); 6625 switch (op[1] & 0x00) 6626 { 6627 case 0x00: 6628 goto op_semantics_42; 6629 break; 6630 } 6631 break; 6632 case 0xc8: 6633 GETBYTE (); 6634 switch (op[1] & 0x00) 6635 { 6636 case 0x00: 6637 goto op_semantics_42; 6638 break; 6639 } 6640 break; 6641 case 0xc9: 6642 GETBYTE (); 6643 switch (op[1] & 0x00) 6644 { 6645 case 0x00: 6646 goto op_semantics_42; 6647 break; 6648 } 6649 break; 6650 case 0xca: 6651 GETBYTE (); 6652 switch (op[1] & 0x00) 6653 { 6654 case 0x00: 6655 goto op_semantics_42; 6656 break; 6657 } 6658 break; 6659 case 0xcb: 6660 GETBYTE (); 6661 switch (op[1] & 0x00) 6662 { 6663 case 0x00: 6664 goto op_semantics_42; 6665 break; 6666 } 6667 break; 6668 case 0xcc: 6669 GETBYTE (); 6670 switch (op[1] & 0x00) 6671 { 6672 case 0x00: 6673 goto op_semantics_42; 6674 break; 6675 } 6676 break; 6677 case 0xcd: 6678 GETBYTE (); 6679 switch (op[1] & 0x00) 6680 { 6681 case 0x00: 6682 goto op_semantics_42; 6683 break; 6684 } 6685 break; 6686 case 0xce: 6687 GETBYTE (); 6688 switch (op[1] & 0x00) 6689 { 6690 case 0x00: 6691 goto op_semantics_42; 6692 break; 6693 } 6694 break; 6695 case 0xcf: 6696 GETBYTE (); 6697 switch (op[1] & 0x00) 6698 { 6699 case 0x00: 6700 goto op_semantics_42; 6701 break; 6702 } 6703 break; 6704 case 0xd0: 6705 GETBYTE (); 6706 switch (op[1] & 0x00) 6707 { 6708 case 0x00: 6709 goto op_semantics_42; 6710 break; 6711 } 6712 break; 6713 case 0xd1: 6714 GETBYTE (); 6715 switch (op[1] & 0x00) 6716 { 6717 case 0x00: 6718 goto op_semantics_42; 6719 break; 6720 } 6721 break; 6722 case 0xd2: 6723 GETBYTE (); 6724 switch (op[1] & 0x00) 6725 { 6726 case 0x00: 6727 goto op_semantics_42; 6728 break; 6729 } 6730 break; 6731 case 0xd3: 6732 GETBYTE (); 6733 switch (op[1] & 0x00) 6734 { 6735 case 0x00: 6736 goto op_semantics_42; 6737 break; 6738 } 6739 break; 6740 case 0xd4: 6741 GETBYTE (); 6742 switch (op[1] & 0x00) 6743 { 6744 case 0x00: 6745 goto op_semantics_42; 6746 break; 6747 } 6748 break; 6749 case 0xd5: 6750 GETBYTE (); 6751 switch (op[1] & 0x00) 6752 { 6753 case 0x00: 6754 goto op_semantics_42; 6755 break; 6756 } 6757 break; 6758 case 0xd6: 6759 GETBYTE (); 6760 switch (op[1] & 0x00) 6761 { 6762 case 0x00: 6763 goto op_semantics_42; 6764 break; 6765 } 6766 break; 6767 case 0xd7: 6768 GETBYTE (); 6769 switch (op[1] & 0x00) 6770 { 6771 case 0x00: 6772 goto op_semantics_42; 6773 break; 6774 } 6775 break; 6776 case 0xd8: 6777 GETBYTE (); 6778 switch (op[1] & 0x00) 6779 { 6780 case 0x00: 6781 goto op_semantics_42; 6782 break; 6783 } 6784 break; 6785 case 0xd9: 6786 GETBYTE (); 6787 switch (op[1] & 0x00) 6788 { 6789 case 0x00: 6790 goto op_semantics_42; 6791 break; 6792 } 6793 break; 6794 case 0xda: 6795 GETBYTE (); 6796 switch (op[1] & 0x00) 6797 { 6798 case 0x00: 6799 goto op_semantics_42; 6800 break; 6801 } 6802 break; 6803 case 0xdb: 6804 GETBYTE (); 6805 switch (op[1] & 0x00) 6806 { 6807 case 0x00: 6808 goto op_semantics_42; 6809 break; 6810 } 6811 break; 6812 case 0xdc: 6813 GETBYTE (); 6814 switch (op[1] & 0x00) 6815 { 6816 case 0x00: 6817 goto op_semantics_42; 6818 break; 6819 } 6820 break; 6821 case 0xdd: 6822 GETBYTE (); 6823 switch (op[1] & 0x00) 6824 { 6825 case 0x00: 6826 goto op_semantics_42; 6827 break; 6828 } 6829 break; 6830 case 0xde: 6831 GETBYTE (); 6832 switch (op[1] & 0x00) 6833 { 6834 case 0x00: 6835 goto op_semantics_42; 6836 break; 6837 } 6838 break; 6839 case 0xdf: 6840 GETBYTE (); 6841 switch (op[1] & 0x00) 6842 { 6843 case 0x00: 6844 goto op_semantics_42; 6845 break; 6846 } 6847 break; 6848 case 0xe0: 6849 GETBYTE (); 6850 switch (op[1] & 0x00) 6851 { 6852 case 0x00: 6853 goto op_semantics_42; 6854 break; 6855 } 6856 break; 6857 case 0xe1: 6858 GETBYTE (); 6859 switch (op[1] & 0x00) 6860 { 6861 case 0x00: 6862 goto op_semantics_42; 6863 break; 6864 } 6865 break; 6866 case 0xe2: 6867 GETBYTE (); 6868 switch (op[1] & 0x00) 6869 { 6870 case 0x00: 6871 goto op_semantics_42; 6872 break; 6873 } 6874 break; 6875 case 0xe3: 6876 GETBYTE (); 6877 switch (op[1] & 0x00) 6878 { 6879 case 0x00: 6880 goto op_semantics_42; 6881 break; 6882 } 6883 break; 6884 case 0xe4: 6885 GETBYTE (); 6886 switch (op[1] & 0x00) 6887 { 6888 case 0x00: 6889 goto op_semantics_42; 6890 break; 6891 } 6892 break; 6893 case 0xe5: 6894 GETBYTE (); 6895 switch (op[1] & 0x00) 6896 { 6897 case 0x00: 6898 goto op_semantics_42; 6899 break; 6900 } 6901 break; 6902 case 0xe6: 6903 GETBYTE (); 6904 switch (op[1] & 0x00) 6905 { 6906 case 0x00: 6907 goto op_semantics_42; 6908 break; 6909 } 6910 break; 6911 case 0xe7: 6912 GETBYTE (); 6913 switch (op[1] & 0x00) 6914 { 6915 case 0x00: 6916 goto op_semantics_42; 6917 break; 6918 } 6919 break; 6920 case 0xe8: 6921 GETBYTE (); 6922 switch (op[1] & 0x00) 6923 { 6924 case 0x00: 6925 goto op_semantics_42; 6926 break; 6927 } 6928 break; 6929 case 0xe9: 6930 GETBYTE (); 6931 switch (op[1] & 0x00) 6932 { 6933 case 0x00: 6934 goto op_semantics_42; 6935 break; 6936 } 6937 break; 6938 case 0xea: 6939 GETBYTE (); 6940 switch (op[1] & 0x00) 6941 { 6942 case 0x00: 6943 goto op_semantics_42; 6944 break; 6945 } 6946 break; 6947 case 0xeb: 6948 GETBYTE (); 6949 switch (op[1] & 0x00) 6950 { 6951 case 0x00: 6952 goto op_semantics_42; 6953 break; 6954 } 6955 break; 6956 case 0xec: 6957 GETBYTE (); 6958 switch (op[1] & 0x00) 6959 { 6960 case 0x00: 6961 goto op_semantics_42; 6962 break; 6963 } 6964 break; 6965 case 0xed: 6966 GETBYTE (); 6967 switch (op[1] & 0x00) 6968 { 6969 case 0x00: 6970 goto op_semantics_42; 6971 break; 6972 } 6973 break; 6974 case 0xee: 6975 GETBYTE (); 6976 switch (op[1] & 0x00) 6977 { 6978 case 0x00: 6979 goto op_semantics_42; 6980 break; 6981 } 6982 break; 6983 case 0xef: 6984 GETBYTE (); 6985 switch (op[1] & 0x00) 6986 { 6987 case 0x00: 6988 goto op_semantics_42; 6989 break; 6990 } 6991 break; 6992 case 0xf0: 6993 GETBYTE (); 6994 switch (op[1] & 0x08) 6995 { 6996 case 0x00: 6997 op_semantics_43: 6998 { 6999 /** 1111 00sd rdst 0bit bset #%1, %0%S0 */ 7000 #line 939 "rx-decode.opc" 7001 int sd AU = op[0] & 0x03; 7002 #line 939 "rx-decode.opc" 7003 int rdst AU = (op[1] >> 4) & 0x0f; 7004 #line 939 "rx-decode.opc" 7005 int bit AU = op[1] & 0x07; 7006 if (trace) 7007 { 7008 printf ("\033[33m%s\033[0m %02x %02x\n", 7009 "/** 1111 00sd rdst 0bit bset #%1, %0%S0 */", 7010 op[0], op[1]); 7011 printf (" sd = 0x%x,", sd); 7012 printf (" rdst = 0x%x,", rdst); 7013 printf (" bit = 0x%x\n", bit); 7014 } 7015 SYNTAX("bset #%1, %0%S0"); 7016 #line 939 "rx-decode.opc" 7017 ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____; 7018 7019 } 7020 break; 7021 case 0x08: 7022 op_semantics_44: 7023 { 7024 /** 1111 00sd rdst 1bit bclr #%1, %0%S0 */ 7025 #line 951 "rx-decode.opc" 7026 int sd AU = op[0] & 0x03; 7027 #line 951 "rx-decode.opc" 7028 int rdst AU = (op[1] >> 4) & 0x0f; 7029 #line 951 "rx-decode.opc" 7030 int bit AU = op[1] & 0x07; 7031 if (trace) 7032 { 7033 printf ("\033[33m%s\033[0m %02x %02x\n", 7034 "/** 1111 00sd rdst 1bit bclr #%1, %0%S0 */", 7035 op[0], op[1]); 7036 printf (" sd = 0x%x,", sd); 7037 printf (" rdst = 0x%x,", rdst); 7038 printf (" bit = 0x%x\n", bit); 7039 } 7040 SYNTAX("bclr #%1, %0%S0"); 7041 #line 951 "rx-decode.opc" 7042 ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____; 7043 7044 } 7045 break; 7046 } 7047 break; 7048 case 0xf1: 7049 GETBYTE (); 7050 switch (op[1] & 0x08) 7051 { 7052 case 0x00: 7053 goto op_semantics_43; 7054 break; 7055 case 0x08: 7056 goto op_semantics_44; 7057 break; 7058 } 7059 break; 7060 case 0xf2: 7061 GETBYTE (); 7062 switch (op[1] & 0x08) 7063 { 7064 case 0x00: 7065 goto op_semantics_43; 7066 break; 7067 case 0x08: 7068 goto op_semantics_44; 7069 break; 7070 } 7071 break; 7072 case 0xf3: 7073 GETBYTE (); 7074 switch (op[1] & 0x08) 7075 { 7076 case 0x00: 7077 goto op_semantics_43; 7078 break; 7079 case 0x08: 7080 goto op_semantics_44; 7081 break; 7082 } 7083 break; 7084 case 0xf4: 7085 GETBYTE (); 7086 switch (op[1] & 0x0c) 7087 { 7088 case 0x00: 7089 case 0x04: 7090 op_semantics_45: 7091 { 7092 /** 1111 01sd rdst 0bit btst #%2, %1%S1 */ 7093 #line 963 "rx-decode.opc" 7094 int sd AU = op[0] & 0x03; 7095 #line 963 "rx-decode.opc" 7096 int rdst AU = (op[1] >> 4) & 0x0f; 7097 #line 963 "rx-decode.opc" 7098 int bit AU = op[1] & 0x07; 7099 if (trace) 7100 { 7101 printf ("\033[33m%s\033[0m %02x %02x\n", 7102 "/** 1111 01sd rdst 0bit btst #%2, %1%S1 */", 7103 op[0], op[1]); 7104 printf (" sd = 0x%x,", sd); 7105 printf (" rdst = 0x%x,", rdst); 7106 printf (" bit = 0x%x\n", bit); 7107 } 7108 SYNTAX("btst #%2, %1%S1"); 7109 #line 963 "rx-decode.opc" 7110 ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F___ZC; 7111 7112 } 7113 break; 7114 case 0x08: 7115 op_semantics_46: 7116 { 7117 /** 1111 01ss rsrc 10sz push%s %1 */ 7118 #line 381 "rx-decode.opc" 7119 int ss AU = op[0] & 0x03; 7120 #line 381 "rx-decode.opc" 7121 int rsrc AU = (op[1] >> 4) & 0x0f; 7122 #line 381 "rx-decode.opc" 7123 int sz AU = op[1] & 0x03; 7124 if (trace) 7125 { 7126 printf ("\033[33m%s\033[0m %02x %02x\n", 7127 "/** 1111 01ss rsrc 10sz push%s %1 */", 7128 op[0], op[1]); 7129 printf (" ss = 0x%x,", ss); 7130 printf (" rsrc = 0x%x,", rsrc); 7131 printf (" sz = 0x%x\n", sz); 7132 } 7133 SYNTAX("push%s %1"); 7134 #line 381 "rx-decode.opc" 7135 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F_____; 7136 7137 /*----------------------------------------------------------------------*/ 7138 /* XCHG */ 7139 7140 } 7141 break; 7142 default: UNSUPPORTED(); break; 7143 } 7144 break; 7145 case 0xf5: 7146 GETBYTE (); 7147 switch (op[1] & 0x0c) 7148 { 7149 case 0x00: 7150 case 0x04: 7151 goto op_semantics_45; 7152 break; 7153 case 0x08: 7154 goto op_semantics_46; 7155 break; 7156 default: UNSUPPORTED(); break; 7157 } 7158 break; 7159 case 0xf6: 7160 GETBYTE (); 7161 switch (op[1] & 0x0c) 7162 { 7163 case 0x00: 7164 case 0x04: 7165 goto op_semantics_45; 7166 break; 7167 case 0x08: 7168 goto op_semantics_46; 7169 break; 7170 default: UNSUPPORTED(); break; 7171 } 7172 break; 7173 case 0xf7: 7174 GETBYTE (); 7175 switch (op[1] & 0x0c) 7176 { 7177 case 0x00: 7178 case 0x04: 7179 goto op_semantics_45; 7180 break; 7181 case 0x08: 7182 goto op_semantics_46; 7183 break; 7184 default: UNSUPPORTED(); break; 7185 } 7186 break; 7187 case 0xf8: 7188 GETBYTE (); 7189 switch (op[1] & 0x00) 7190 { 7191 case 0x00: 7192 op_semantics_47: 7193 { 7194 /** 1111 10sd rdst im sz mov%s #%1, %0 */ 7195 #line 292 "rx-decode.opc" 7196 int sd AU = op[0] & 0x03; 7197 #line 292 "rx-decode.opc" 7198 int rdst AU = (op[1] >> 4) & 0x0f; 7199 #line 292 "rx-decode.opc" 7200 int im AU = (op[1] >> 2) & 0x03; 7201 #line 292 "rx-decode.opc" 7202 int sz AU = op[1] & 0x03; 7203 if (trace) 7204 { 7205 printf ("\033[33m%s\033[0m %02x %02x\n", 7206 "/** 1111 10sd rdst im sz mov%s #%1, %0 */", 7207 op[0], op[1]); 7208 printf (" sd = 0x%x,", sd); 7209 printf (" rdst = 0x%x,", rdst); 7210 printf (" im = 0x%x,", im); 7211 printf (" sz = 0x%x\n", sz); 7212 } 7213 SYNTAX("mov%s #%1, %0"); 7214 #line 292 "rx-decode.opc" 7215 ID(mov); DD(sd, rdst, sz); 7216 if ((im == 1 && sz == 0) 7217 || (im == 2 && sz == 1) 7218 || (im == 0 && sz == 2)) 7219 { 7220 BWL (sz); 7221 SC(IMM(im)); 7222 } 7223 else 7224 { 7225 sBWL (sz); 7226 SC(IMMex(im)); 7227 } 7228 F_____; 7229 7230 } 7231 break; 7232 } 7233 break; 7234 case 0xf9: 7235 GETBYTE (); 7236 switch (op[1] & 0x00) 7237 { 7238 case 0x00: 7239 goto op_semantics_47; 7240 break; 7241 } 7242 break; 7243 case 0xfa: 7244 GETBYTE (); 7245 switch (op[1] & 0x00) 7246 { 7247 case 0x00: 7248 goto op_semantics_47; 7249 break; 7250 } 7251 break; 7252 case 0xfb: 7253 GETBYTE (); 7254 switch (op[1] & 0x00) 7255 { 7256 case 0x00: 7257 goto op_semantics_47; 7258 break; 7259 } 7260 break; 7261 case 0xfc: 7262 GETBYTE (); 7263 switch (op[1] & 0xff) 7264 { 7265 case 0x03: 7266 GETBYTE (); 7267 switch (op[2] & 0x00) 7268 { 7269 case 0x00: 7270 { 7271 /** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */ 7272 #line 555 "rx-decode.opc" 7273 int rsrc AU = (op[2] >> 4) & 0x0f; 7274 #line 555 "rx-decode.opc" 7275 int rdst AU = op[2] & 0x0f; 7276 if (trace) 7277 { 7278 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7279 "/** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */", 7280 op[0], op[1], op[2]); 7281 printf (" rsrc = 0x%x,", rsrc); 7282 printf (" rdst = 0x%x\n", rdst); 7283 } 7284 SYNTAX("sbb %1, %0"); 7285 #line 555 "rx-decode.opc" 7286 ID(sbb); SR (rsrc); DR(rdst); F_OSZC; 7287 7288 /* FIXME: only supports .L */ 7289 } 7290 break; 7291 } 7292 break; 7293 case 0x07: 7294 GETBYTE (); 7295 switch (op[2] & 0x00) 7296 { 7297 case 0x00: 7298 { 7299 /** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */ 7300 #line 486 "rx-decode.opc" 7301 int rsrc AU = (op[2] >> 4) & 0x0f; 7302 #line 486 "rx-decode.opc" 7303 int rdst AU = op[2] & 0x0f; 7304 if (trace) 7305 { 7306 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7307 "/** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */", 7308 op[0], op[1], op[2]); 7309 printf (" rsrc = 0x%x,", rsrc); 7310 printf (" rdst = 0x%x\n", rdst); 7311 } 7312 SYNTAX("neg %2, %0"); 7313 #line 486 "rx-decode.opc" 7314 ID(sub); DR(rdst); SC(0); S2R(rsrc); F_OSZC; 7315 7316 /*----------------------------------------------------------------------*/ 7317 /* ADC */ 7318 7319 } 7320 break; 7321 } 7322 break; 7323 case 0x0b: 7324 GETBYTE (); 7325 switch (op[2] & 0x00) 7326 { 7327 case 0x00: 7328 { 7329 /** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */ 7330 #line 495 "rx-decode.opc" 7331 int rsrc AU = (op[2] >> 4) & 0x0f; 7332 #line 495 "rx-decode.opc" 7333 int rdst AU = op[2] & 0x0f; 7334 if (trace) 7335 { 7336 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7337 "/** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */", 7338 op[0], op[1], op[2]); 7339 printf (" rsrc = 0x%x,", rsrc); 7340 printf (" rdst = 0x%x\n", rdst); 7341 } 7342 SYNTAX("adc %1, %0"); 7343 #line 495 "rx-decode.opc" 7344 ID(adc); SR(rsrc); DR(rdst); F_OSZC; 7345 7346 } 7347 break; 7348 } 7349 break; 7350 case 0x0f: 7351 GETBYTE (); 7352 switch (op[2] & 0x00) 7353 { 7354 case 0x00: 7355 { 7356 /** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */ 7357 #line 568 "rx-decode.opc" 7358 int rsrc AU = (op[2] >> 4) & 0x0f; 7359 #line 568 "rx-decode.opc" 7360 int rdst AU = op[2] & 0x0f; 7361 if (trace) 7362 { 7363 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7364 "/** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */", 7365 op[0], op[1], op[2]); 7366 printf (" rsrc = 0x%x,", rsrc); 7367 printf (" rdst = 0x%x\n", rdst); 7368 } 7369 SYNTAX("abs %1, %0"); 7370 #line 568 "rx-decode.opc" 7371 ID(abs); DR(rdst); SR(rsrc); F_OSZ_; 7372 7373 /*----------------------------------------------------------------------*/ 7374 /* MAX */ 7375 7376 } 7377 break; 7378 } 7379 break; 7380 case 0x10: 7381 GETBYTE (); 7382 switch (op[2] & 0x00) 7383 { 7384 case 0x00: 7385 op_semantics_48: 7386 { 7387 /** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */ 7388 #line 587 "rx-decode.opc" 7389 int ss AU = op[1] & 0x03; 7390 #line 587 "rx-decode.opc" 7391 int rsrc AU = (op[2] >> 4) & 0x0f; 7392 #line 587 "rx-decode.opc" 7393 int rdst AU = op[2] & 0x0f; 7394 if (trace) 7395 { 7396 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7397 "/** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */", 7398 op[0], op[1], op[2]); 7399 printf (" ss = 0x%x,", ss); 7400 printf (" rsrc = 0x%x,", rsrc); 7401 printf (" rdst = 0x%x\n", rdst); 7402 } 7403 SYNTAX("max %1%S1, %0"); 7404 #line 587 "rx-decode.opc" 7405 if (ss == 3 && rsrc == 0 && rdst == 0) 7406 { 7407 ID(nop3); 7408 SYNTAX("nop\t; max\tr0, r0"); 7409 } 7410 else 7411 { 7412 ID(max); SP(ss, rsrc); DR(rdst); 7413 } 7414 7415 } 7416 break; 7417 } 7418 break; 7419 case 0x11: 7420 GETBYTE (); 7421 switch (op[2] & 0x00) 7422 { 7423 case 0x00: 7424 goto op_semantics_48; 7425 break; 7426 } 7427 break; 7428 case 0x12: 7429 GETBYTE (); 7430 switch (op[2] & 0x00) 7431 { 7432 case 0x00: 7433 goto op_semantics_48; 7434 break; 7435 } 7436 break; 7437 case 0x13: 7438 GETBYTE (); 7439 switch (op[2] & 0x00) 7440 { 7441 case 0x00: 7442 goto op_semantics_48; 7443 break; 7444 } 7445 break; 7446 case 0x14: 7447 GETBYTE (); 7448 switch (op[2] & 0x00) 7449 { 7450 case 0x00: 7451 op_semantics_49: 7452 { 7453 /** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */ 7454 #line 607 "rx-decode.opc" 7455 int ss AU = op[1] & 0x03; 7456 #line 607 "rx-decode.opc" 7457 int rsrc AU = (op[2] >> 4) & 0x0f; 7458 #line 607 "rx-decode.opc" 7459 int rdst AU = op[2] & 0x0f; 7460 if (trace) 7461 { 7462 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7463 "/** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */", 7464 op[0], op[1], op[2]); 7465 printf (" ss = 0x%x,", ss); 7466 printf (" rsrc = 0x%x,", rsrc); 7467 printf (" rdst = 0x%x\n", rdst); 7468 } 7469 SYNTAX("min %1%S1, %0"); 7470 #line 607 "rx-decode.opc" 7471 ID(min); SP(ss, rsrc); DR(rdst); 7472 7473 } 7474 break; 7475 } 7476 break; 7477 case 0x15: 7478 GETBYTE (); 7479 switch (op[2] & 0x00) 7480 { 7481 case 0x00: 7482 goto op_semantics_49; 7483 break; 7484 } 7485 break; 7486 case 0x16: 7487 GETBYTE (); 7488 switch (op[2] & 0x00) 7489 { 7490 case 0x00: 7491 goto op_semantics_49; 7492 break; 7493 } 7494 break; 7495 case 0x17: 7496 GETBYTE (); 7497 switch (op[2] & 0x00) 7498 { 7499 case 0x00: 7500 goto op_semantics_49; 7501 break; 7502 } 7503 break; 7504 case 0x18: 7505 GETBYTE (); 7506 switch (op[2] & 0x00) 7507 { 7508 case 0x00: 7509 op_semantics_50: 7510 { 7511 /** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */ 7512 #line 665 "rx-decode.opc" 7513 int ss AU = op[1] & 0x03; 7514 #line 665 "rx-decode.opc" 7515 int rsrc AU = (op[2] >> 4) & 0x0f; 7516 #line 665 "rx-decode.opc" 7517 int rdst AU = op[2] & 0x0f; 7518 if (trace) 7519 { 7520 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7521 "/** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */", 7522 op[0], op[1], op[2]); 7523 printf (" ss = 0x%x,", ss); 7524 printf (" rsrc = 0x%x,", rsrc); 7525 printf (" rdst = 0x%x\n", rdst); 7526 } 7527 SYNTAX("emul %1%S1, %0"); 7528 #line 665 "rx-decode.opc" 7529 ID(emul); SP(ss, rsrc); DR(rdst); 7530 7531 } 7532 break; 7533 } 7534 break; 7535 case 0x19: 7536 GETBYTE (); 7537 switch (op[2] & 0x00) 7538 { 7539 case 0x00: 7540 goto op_semantics_50; 7541 break; 7542 } 7543 break; 7544 case 0x1a: 7545 GETBYTE (); 7546 switch (op[2] & 0x00) 7547 { 7548 case 0x00: 7549 goto op_semantics_50; 7550 break; 7551 } 7552 break; 7553 case 0x1b: 7554 GETBYTE (); 7555 switch (op[2] & 0x00) 7556 { 7557 case 0x00: 7558 goto op_semantics_50; 7559 break; 7560 } 7561 break; 7562 case 0x1c: 7563 GETBYTE (); 7564 switch (op[2] & 0x00) 7565 { 7566 case 0x00: 7567 op_semantics_51: 7568 { 7569 /** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */ 7570 #line 677 "rx-decode.opc" 7571 int ss AU = op[1] & 0x03; 7572 #line 677 "rx-decode.opc" 7573 int rsrc AU = (op[2] >> 4) & 0x0f; 7574 #line 677 "rx-decode.opc" 7575 int rdst AU = op[2] & 0x0f; 7576 if (trace) 7577 { 7578 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7579 "/** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */", 7580 op[0], op[1], op[2]); 7581 printf (" ss = 0x%x,", ss); 7582 printf (" rsrc = 0x%x,", rsrc); 7583 printf (" rdst = 0x%x\n", rdst); 7584 } 7585 SYNTAX("emulu %1%S1, %0"); 7586 #line 677 "rx-decode.opc" 7587 ID(emulu); SP(ss, rsrc); DR(rdst); 7588 7589 } 7590 break; 7591 } 7592 break; 7593 case 0x1d: 7594 GETBYTE (); 7595 switch (op[2] & 0x00) 7596 { 7597 case 0x00: 7598 goto op_semantics_51; 7599 break; 7600 } 7601 break; 7602 case 0x1e: 7603 GETBYTE (); 7604 switch (op[2] & 0x00) 7605 { 7606 case 0x00: 7607 goto op_semantics_51; 7608 break; 7609 } 7610 break; 7611 case 0x1f: 7612 GETBYTE (); 7613 switch (op[2] & 0x00) 7614 { 7615 case 0x00: 7616 goto op_semantics_51; 7617 break; 7618 } 7619 break; 7620 case 0x20: 7621 GETBYTE (); 7622 switch (op[2] & 0x00) 7623 { 7624 case 0x00: 7625 op_semantics_52: 7626 { 7627 /** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */ 7628 #line 689 "rx-decode.opc" 7629 int ss AU = op[1] & 0x03; 7630 #line 689 "rx-decode.opc" 7631 int rsrc AU = (op[2] >> 4) & 0x0f; 7632 #line 689 "rx-decode.opc" 7633 int rdst AU = op[2] & 0x0f; 7634 if (trace) 7635 { 7636 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7637 "/** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */", 7638 op[0], op[1], op[2]); 7639 printf (" ss = 0x%x,", ss); 7640 printf (" rsrc = 0x%x,", rsrc); 7641 printf (" rdst = 0x%x\n", rdst); 7642 } 7643 SYNTAX("div %1%S1, %0"); 7644 #line 689 "rx-decode.opc" 7645 ID(div); SP(ss, rsrc); DR(rdst); F_O___; 7646 7647 } 7648 break; 7649 } 7650 break; 7651 case 0x21: 7652 GETBYTE (); 7653 switch (op[2] & 0x00) 7654 { 7655 case 0x00: 7656 goto op_semantics_52; 7657 break; 7658 } 7659 break; 7660 case 0x22: 7661 GETBYTE (); 7662 switch (op[2] & 0x00) 7663 { 7664 case 0x00: 7665 goto op_semantics_52; 7666 break; 7667 } 7668 break; 7669 case 0x23: 7670 GETBYTE (); 7671 switch (op[2] & 0x00) 7672 { 7673 case 0x00: 7674 goto op_semantics_52; 7675 break; 7676 } 7677 break; 7678 case 0x24: 7679 GETBYTE (); 7680 switch (op[2] & 0x00) 7681 { 7682 case 0x00: 7683 op_semantics_53: 7684 { 7685 /** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */ 7686 #line 701 "rx-decode.opc" 7687 int ss AU = op[1] & 0x03; 7688 #line 701 "rx-decode.opc" 7689 int rsrc AU = (op[2] >> 4) & 0x0f; 7690 #line 701 "rx-decode.opc" 7691 int rdst AU = op[2] & 0x0f; 7692 if (trace) 7693 { 7694 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7695 "/** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */", 7696 op[0], op[1], op[2]); 7697 printf (" ss = 0x%x,", ss); 7698 printf (" rsrc = 0x%x,", rsrc); 7699 printf (" rdst = 0x%x\n", rdst); 7700 } 7701 SYNTAX("divu %1%S1, %0"); 7702 #line 701 "rx-decode.opc" 7703 ID(divu); SP(ss, rsrc); DR(rdst); F_O___; 7704 7705 } 7706 break; 7707 } 7708 break; 7709 case 0x25: 7710 GETBYTE (); 7711 switch (op[2] & 0x00) 7712 { 7713 case 0x00: 7714 goto op_semantics_53; 7715 break; 7716 } 7717 break; 7718 case 0x26: 7719 GETBYTE (); 7720 switch (op[2] & 0x00) 7721 { 7722 case 0x00: 7723 goto op_semantics_53; 7724 break; 7725 } 7726 break; 7727 case 0x27: 7728 GETBYTE (); 7729 switch (op[2] & 0x00) 7730 { 7731 case 0x00: 7732 goto op_semantics_53; 7733 break; 7734 } 7735 break; 7736 case 0x30: 7737 GETBYTE (); 7738 switch (op[2] & 0x00) 7739 { 7740 case 0x00: 7741 op_semantics_54: 7742 { 7743 /** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */ 7744 #line 474 "rx-decode.opc" 7745 int ss AU = op[1] & 0x03; 7746 #line 474 "rx-decode.opc" 7747 int rsrc AU = (op[2] >> 4) & 0x0f; 7748 #line 474 "rx-decode.opc" 7749 int rdst AU = op[2] & 0x0f; 7750 if (trace) 7751 { 7752 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7753 "/** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */", 7754 op[0], op[1], op[2]); 7755 printf (" ss = 0x%x,", ss); 7756 printf (" rsrc = 0x%x,", rsrc); 7757 printf (" rdst = 0x%x\n", rdst); 7758 } 7759 SYNTAX("tst %1%S1, %2"); 7760 #line 474 "rx-decode.opc" 7761 ID(and); SP(ss, rsrc); S2R(rdst); F__SZ_; 7762 7763 } 7764 break; 7765 } 7766 break; 7767 case 0x31: 7768 GETBYTE (); 7769 switch (op[2] & 0x00) 7770 { 7771 case 0x00: 7772 goto op_semantics_54; 7773 break; 7774 } 7775 break; 7776 case 0x32: 7777 GETBYTE (); 7778 switch (op[2] & 0x00) 7779 { 7780 case 0x00: 7781 goto op_semantics_54; 7782 break; 7783 } 7784 break; 7785 case 0x33: 7786 GETBYTE (); 7787 switch (op[2] & 0x00) 7788 { 7789 case 0x00: 7790 goto op_semantics_54; 7791 break; 7792 } 7793 break; 7794 case 0x34: 7795 GETBYTE (); 7796 switch (op[2] & 0x00) 7797 { 7798 case 0x00: 7799 op_semantics_55: 7800 { 7801 /** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */ 7802 #line 453 "rx-decode.opc" 7803 int ss AU = op[1] & 0x03; 7804 #line 453 "rx-decode.opc" 7805 int rsrc AU = (op[2] >> 4) & 0x0f; 7806 #line 453 "rx-decode.opc" 7807 int rdst AU = op[2] & 0x0f; 7808 if (trace) 7809 { 7810 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7811 "/** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */", 7812 op[0], op[1], op[2]); 7813 printf (" ss = 0x%x,", ss); 7814 printf (" rsrc = 0x%x,", rsrc); 7815 printf (" rdst = 0x%x\n", rdst); 7816 } 7817 SYNTAX("xor %1%S1, %0"); 7818 #line 453 "rx-decode.opc" 7819 ID(xor); SP(ss, rsrc); DR(rdst); F__SZ_; 7820 7821 } 7822 break; 7823 } 7824 break; 7825 case 0x35: 7826 GETBYTE (); 7827 switch (op[2] & 0x00) 7828 { 7829 case 0x00: 7830 goto op_semantics_55; 7831 break; 7832 } 7833 break; 7834 case 0x36: 7835 GETBYTE (); 7836 switch (op[2] & 0x00) 7837 { 7838 case 0x00: 7839 goto op_semantics_55; 7840 break; 7841 } 7842 break; 7843 case 0x37: 7844 GETBYTE (); 7845 switch (op[2] & 0x00) 7846 { 7847 case 0x00: 7848 goto op_semantics_55; 7849 break; 7850 } 7851 break; 7852 case 0x3b: 7853 GETBYTE (); 7854 switch (op[2] & 0x00) 7855 { 7856 case 0x00: 7857 { 7858 /** 1111 1100 0011 1011 rsrc rdst not %1, %0 */ 7859 #line 465 "rx-decode.opc" 7860 int rsrc AU = (op[2] >> 4) & 0x0f; 7861 #line 465 "rx-decode.opc" 7862 int rdst AU = op[2] & 0x0f; 7863 if (trace) 7864 { 7865 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7866 "/** 1111 1100 0011 1011 rsrc rdst not %1, %0 */", 7867 op[0], op[1], op[2]); 7868 printf (" rsrc = 0x%x,", rsrc); 7869 printf (" rdst = 0x%x\n", rdst); 7870 } 7871 SYNTAX("not %1, %0"); 7872 #line 465 "rx-decode.opc" 7873 ID(xor); DR(rdst); SR(rsrc); S2C(~0); F__SZ_; 7874 7875 /*----------------------------------------------------------------------*/ 7876 /* TST */ 7877 7878 } 7879 break; 7880 } 7881 break; 7882 case 0x40: 7883 GETBYTE (); 7884 switch (op[2] & 0x00) 7885 { 7886 case 0x00: 7887 op_semantics_56: 7888 { 7889 /** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */ 7890 #line 387 "rx-decode.opc" 7891 int ss AU = op[1] & 0x03; 7892 #line 387 "rx-decode.opc" 7893 int rsrc AU = (op[2] >> 4) & 0x0f; 7894 #line 387 "rx-decode.opc" 7895 int rdst AU = op[2] & 0x0f; 7896 if (trace) 7897 { 7898 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7899 "/** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */", 7900 op[0], op[1], op[2]); 7901 printf (" ss = 0x%x,", ss); 7902 printf (" rsrc = 0x%x,", rsrc); 7903 printf (" rdst = 0x%x\n", rdst); 7904 } 7905 SYNTAX("xchg %1%S1, %0"); 7906 #line 387 "rx-decode.opc" 7907 ID(xchg); DR(rdst); SP(ss, rsrc); 7908 7909 } 7910 break; 7911 } 7912 break; 7913 case 0x41: 7914 GETBYTE (); 7915 switch (op[2] & 0x00) 7916 { 7917 case 0x00: 7918 goto op_semantics_56; 7919 break; 7920 } 7921 break; 7922 case 0x42: 7923 GETBYTE (); 7924 switch (op[2] & 0x00) 7925 { 7926 case 0x00: 7927 goto op_semantics_56; 7928 break; 7929 } 7930 break; 7931 case 0x43: 7932 GETBYTE (); 7933 switch (op[2] & 0x00) 7934 { 7935 case 0x00: 7936 goto op_semantics_56; 7937 break; 7938 } 7939 break; 7940 case 0x44: 7941 GETBYTE (); 7942 switch (op[2] & 0x00) 7943 { 7944 case 0x00: 7945 op_semantics_57: 7946 { 7947 /** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */ 7948 #line 930 "rx-decode.opc" 7949 int sd AU = op[1] & 0x03; 7950 #line 930 "rx-decode.opc" 7951 int rsrc AU = (op[2] >> 4) & 0x0f; 7952 #line 930 "rx-decode.opc" 7953 int rdst AU = op[2] & 0x0f; 7954 if (trace) 7955 { 7956 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7957 "/** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */", 7958 op[0], op[1], op[2]); 7959 printf (" sd = 0x%x,", sd); 7960 printf (" rsrc = 0x%x,", rsrc); 7961 printf (" rdst = 0x%x\n", rdst); 7962 } 7963 SYNTAX("itof %1%S1, %0"); 7964 #line 930 "rx-decode.opc" 7965 ID(itof); DR (rdst); SP(sd, rsrc); F__SZ_; 7966 7967 } 7968 break; 7969 } 7970 break; 7971 case 0x45: 7972 GETBYTE (); 7973 switch (op[2] & 0x00) 7974 { 7975 case 0x00: 7976 goto op_semantics_57; 7977 break; 7978 } 7979 break; 7980 case 0x46: 7981 GETBYTE (); 7982 switch (op[2] & 0x00) 7983 { 7984 case 0x00: 7985 goto op_semantics_57; 7986 break; 7987 } 7988 break; 7989 case 0x47: 7990 GETBYTE (); 7991 switch (op[2] & 0x00) 7992 { 7993 case 0x00: 7994 goto op_semantics_57; 7995 break; 7996 } 7997 break; 7998 case 0x4b: 7999 GETBYTE (); 8000 switch (op[2] & 0x00) 8001 { 8002 case 0x00: 8003 { 8004 /** 1111 1100 0100 1011 rsrc rdst stz %1, %0 */ 8005 #line 1056 "rx-decode.opc" 8006 int rsrc AU = (op[2] >> 4) & 0x0f; 8007 #line 1056 "rx-decode.opc" 8008 int rdst AU = op[2] & 0x0f; 8009 if (trace) 8010 { 8011 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8012 "/** 1111 1100 0100 1011 rsrc rdst stz %1, %0 */", 8013 op[0], op[1], op[2]); 8014 printf (" rsrc = 0x%x,", rsrc); 8015 printf (" rdst = 0x%x\n", rdst); 8016 } 8017 SYNTAX("stz %1, %0"); 8018 #line 1056 "rx-decode.opc" 8019 ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_z); 8020 8021 } 8022 break; 8023 } 8024 break; 8025 case 0x4f: 8026 GETBYTE (); 8027 switch (op[2] & 0x00) 8028 { 8029 case 0x00: 8030 { 8031 /** 1111 1100 0100 1111 rsrc rdst stnz %1, %0 */ 8032 #line 1059 "rx-decode.opc" 8033 int rsrc AU = (op[2] >> 4) & 0x0f; 8034 #line 1059 "rx-decode.opc" 8035 int rdst AU = op[2] & 0x0f; 8036 if (trace) 8037 { 8038 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8039 "/** 1111 1100 0100 1111 rsrc rdst stnz %1, %0 */", 8040 op[0], op[1], op[2]); 8041 printf (" rsrc = 0x%x,", rsrc); 8042 printf (" rdst = 0x%x\n", rdst); 8043 } 8044 SYNTAX("stnz %1, %0"); 8045 #line 1059 "rx-decode.opc" 8046 ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_nz); 8047 8048 } 8049 break; 8050 } 8051 break; 8052 case 0x54: 8053 GETBYTE (); 8054 switch (op[2] & 0x00) 8055 { 8056 case 0x00: 8057 op_semantics_58: 8058 { 8059 /** 1111 1100 0101 01sd rsrc rdst utof %1%S1, %0 */ 8060 #line 1116 "rx-decode.opc" 8061 int sd AU = op[1] & 0x03; 8062 #line 1116 "rx-decode.opc" 8063 int rsrc AU = (op[2] >> 4) & 0x0f; 8064 #line 1116 "rx-decode.opc" 8065 int rdst AU = op[2] & 0x0f; 8066 if (trace) 8067 { 8068 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8069 "/** 1111 1100 0101 01sd rsrc rdst utof %1%S1, %0 */", 8070 op[0], op[1], op[2]); 8071 printf (" sd = 0x%x,", sd); 8072 printf (" rsrc = 0x%x,", rsrc); 8073 printf (" rdst = 0x%x\n", rdst); 8074 } 8075 SYNTAX("utof %1%S1, %0"); 8076 #line 1116 "rx-decode.opc" 8077 ID(utof); DR (rdst); SP(sd, rsrc); F__SZ_; 8078 8079 } 8080 break; 8081 } 8082 break; 8083 case 0x55: 8084 GETBYTE (); 8085 switch (op[2] & 0x00) 8086 { 8087 case 0x00: 8088 goto op_semantics_58; 8089 break; 8090 } 8091 break; 8092 case 0x56: 8093 GETBYTE (); 8094 switch (op[2] & 0x00) 8095 { 8096 case 0x00: 8097 goto op_semantics_58; 8098 break; 8099 } 8100 break; 8101 case 0x57: 8102 GETBYTE (); 8103 switch (op[2] & 0x00) 8104 { 8105 case 0x00: 8106 goto op_semantics_58; 8107 break; 8108 } 8109 break; 8110 case 0x60: 8111 GETBYTE (); 8112 switch (op[2] & 0x00) 8113 { 8114 case 0x00: 8115 op_semantics_59: 8116 { 8117 /** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */ 8118 #line 942 "rx-decode.opc" 8119 int sd AU = op[1] & 0x03; 8120 #line 942 "rx-decode.opc" 8121 int rdst AU = (op[2] >> 4) & 0x0f; 8122 #line 942 "rx-decode.opc" 8123 int rsrc AU = op[2] & 0x0f; 8124 if (trace) 8125 { 8126 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8127 "/** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */", 8128 op[0], op[1], op[2]); 8129 printf (" sd = 0x%x,", sd); 8130 printf (" rdst = 0x%x,", rdst); 8131 printf (" rsrc = 0x%x\n", rsrc); 8132 } 8133 SYNTAX("bset %1, %0%S0"); 8134 #line 942 "rx-decode.opc" 8135 ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____; 8136 if (sd == 3) /* bset reg,reg */ 8137 BWL(LSIZE); 8138 8139 } 8140 break; 8141 } 8142 break; 8143 case 0x61: 8144 GETBYTE (); 8145 switch (op[2] & 0x00) 8146 { 8147 case 0x00: 8148 goto op_semantics_59; 8149 break; 8150 } 8151 break; 8152 case 0x62: 8153 GETBYTE (); 8154 switch (op[2] & 0x00) 8155 { 8156 case 0x00: 8157 goto op_semantics_59; 8158 break; 8159 } 8160 break; 8161 case 0x63: 8162 GETBYTE (); 8163 switch (op[2] & 0x00) 8164 { 8165 case 0x00: 8166 goto op_semantics_59; 8167 break; 8168 } 8169 break; 8170 case 0x64: 8171 GETBYTE (); 8172 switch (op[2] & 0x00) 8173 { 8174 case 0x00: 8175 op_semantics_60: 8176 { 8177 /** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */ 8178 #line 954 "rx-decode.opc" 8179 int sd AU = op[1] & 0x03; 8180 #line 954 "rx-decode.opc" 8181 int rdst AU = (op[2] >> 4) & 0x0f; 8182 #line 954 "rx-decode.opc" 8183 int rsrc AU = op[2] & 0x0f; 8184 if (trace) 8185 { 8186 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8187 "/** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */", 8188 op[0], op[1], op[2]); 8189 printf (" sd = 0x%x,", sd); 8190 printf (" rdst = 0x%x,", rdst); 8191 printf (" rsrc = 0x%x\n", rsrc); 8192 } 8193 SYNTAX("bclr %1, %0%S0"); 8194 #line 954 "rx-decode.opc" 8195 ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____; 8196 if (sd == 3) /* bset reg,reg */ 8197 BWL(LSIZE); 8198 8199 } 8200 break; 8201 } 8202 break; 8203 case 0x65: 8204 GETBYTE (); 8205 switch (op[2] & 0x00) 8206 { 8207 case 0x00: 8208 goto op_semantics_60; 8209 break; 8210 } 8211 break; 8212 case 0x66: 8213 GETBYTE (); 8214 switch (op[2] & 0x00) 8215 { 8216 case 0x00: 8217 goto op_semantics_60; 8218 break; 8219 } 8220 break; 8221 case 0x67: 8222 GETBYTE (); 8223 switch (op[2] & 0x00) 8224 { 8225 case 0x00: 8226 goto op_semantics_60; 8227 break; 8228 } 8229 break; 8230 case 0x68: 8231 GETBYTE (); 8232 switch (op[2] & 0x00) 8233 { 8234 case 0x00: 8235 op_semantics_61: 8236 { 8237 /** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */ 8238 #line 966 "rx-decode.opc" 8239 int sd AU = op[1] & 0x03; 8240 #line 966 "rx-decode.opc" 8241 int rdst AU = (op[2] >> 4) & 0x0f; 8242 #line 966 "rx-decode.opc" 8243 int rsrc AU = op[2] & 0x0f; 8244 if (trace) 8245 { 8246 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8247 "/** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */", 8248 op[0], op[1], op[2]); 8249 printf (" sd = 0x%x,", sd); 8250 printf (" rdst = 0x%x,", rdst); 8251 printf (" rsrc = 0x%x\n", rsrc); 8252 } 8253 SYNTAX("btst %2, %1%S1"); 8254 #line 966 "rx-decode.opc" 8255 ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ZC; 8256 if (sd == 3) /* bset reg,reg */ 8257 BWL(LSIZE); 8258 8259 } 8260 break; 8261 } 8262 break; 8263 case 0x69: 8264 GETBYTE (); 8265 switch (op[2] & 0x00) 8266 { 8267 case 0x00: 8268 goto op_semantics_61; 8269 break; 8270 } 8271 break; 8272 case 0x6a: 8273 GETBYTE (); 8274 switch (op[2] & 0x00) 8275 { 8276 case 0x00: 8277 goto op_semantics_61; 8278 break; 8279 } 8280 break; 8281 case 0x6b: 8282 GETBYTE (); 8283 switch (op[2] & 0x00) 8284 { 8285 case 0x00: 8286 goto op_semantics_61; 8287 break; 8288 } 8289 break; 8290 case 0x6c: 8291 GETBYTE (); 8292 switch (op[2] & 0x00) 8293 { 8294 case 0x00: 8295 op_semantics_62: 8296 { 8297 /** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */ 8298 #line 978 "rx-decode.opc" 8299 int sd AU = op[1] & 0x03; 8300 #line 978 "rx-decode.opc" 8301 int rdst AU = (op[2] >> 4) & 0x0f; 8302 #line 978 "rx-decode.opc" 8303 int rsrc AU = op[2] & 0x0f; 8304 if (trace) 8305 { 8306 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8307 "/** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */", 8308 op[0], op[1], op[2]); 8309 printf (" sd = 0x%x,", sd); 8310 printf (" rdst = 0x%x,", rdst); 8311 printf (" rsrc = 0x%x\n", rsrc); 8312 } 8313 SYNTAX("bnot %1, %0%S0"); 8314 #line 978 "rx-decode.opc" 8315 ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); 8316 if (sd == 3) /* bset reg,reg */ 8317 BWL(LSIZE); 8318 8319 } 8320 break; 8321 } 8322 break; 8323 case 0x6d: 8324 GETBYTE (); 8325 switch (op[2] & 0x00) 8326 { 8327 case 0x00: 8328 goto op_semantics_62; 8329 break; 8330 } 8331 break; 8332 case 0x6e: 8333 GETBYTE (); 8334 switch (op[2] & 0x00) 8335 { 8336 case 0x00: 8337 goto op_semantics_62; 8338 break; 8339 } 8340 break; 8341 case 0x6f: 8342 GETBYTE (); 8343 switch (op[2] & 0x00) 8344 { 8345 case 0x00: 8346 goto op_semantics_62; 8347 break; 8348 } 8349 break; 8350 case 0x80: 8351 GETBYTE (); 8352 switch (op[2] & 0x00) 8353 { 8354 case 0x00: 8355 op_semantics_63: 8356 { 8357 /** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */ 8358 #line 909 "rx-decode.opc" 8359 int sd AU = op[1] & 0x03; 8360 #line 909 "rx-decode.opc" 8361 int rsrc AU = (op[2] >> 4) & 0x0f; 8362 #line 909 "rx-decode.opc" 8363 int rdst AU = op[2] & 0x0f; 8364 if (trace) 8365 { 8366 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8367 "/** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */", 8368 op[0], op[1], op[2]); 8369 printf (" sd = 0x%x,", sd); 8370 printf (" rsrc = 0x%x,", rsrc); 8371 printf (" rdst = 0x%x\n", rdst); 8372 } 8373 SYNTAX("fsub %1%S1, %0"); 8374 #line 909 "rx-decode.opc" 8375 ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8376 8377 } 8378 break; 8379 } 8380 break; 8381 case 0x81: 8382 GETBYTE (); 8383 switch (op[2] & 0x00) 8384 { 8385 case 0x00: 8386 goto op_semantics_63; 8387 break; 8388 } 8389 break; 8390 case 0x82: 8391 GETBYTE (); 8392 switch (op[2] & 0x00) 8393 { 8394 case 0x00: 8395 goto op_semantics_63; 8396 break; 8397 } 8398 break; 8399 case 0x83: 8400 GETBYTE (); 8401 switch (op[2] & 0x00) 8402 { 8403 case 0x00: 8404 goto op_semantics_63; 8405 break; 8406 } 8407 break; 8408 case 0x84: 8409 GETBYTE (); 8410 switch (op[2] & 0x00) 8411 { 8412 case 0x00: 8413 op_semantics_64: 8414 { 8415 /** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */ 8416 #line 903 "rx-decode.opc" 8417 int sd AU = op[1] & 0x03; 8418 #line 903 "rx-decode.opc" 8419 int rsrc AU = (op[2] >> 4) & 0x0f; 8420 #line 903 "rx-decode.opc" 8421 int rdst AU = op[2] & 0x0f; 8422 if (trace) 8423 { 8424 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8425 "/** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */", 8426 op[0], op[1], op[2]); 8427 printf (" sd = 0x%x,", sd); 8428 printf (" rsrc = 0x%x,", rsrc); 8429 printf (" rdst = 0x%x\n", rdst); 8430 } 8431 SYNTAX("fcmp %1%S1, %0"); 8432 #line 903 "rx-decode.opc" 8433 ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F_OSZ_; 8434 8435 } 8436 break; 8437 } 8438 break; 8439 case 0x85: 8440 GETBYTE (); 8441 switch (op[2] & 0x00) 8442 { 8443 case 0x00: 8444 goto op_semantics_64; 8445 break; 8446 } 8447 break; 8448 case 0x86: 8449 GETBYTE (); 8450 switch (op[2] & 0x00) 8451 { 8452 case 0x00: 8453 goto op_semantics_64; 8454 break; 8455 } 8456 break; 8457 case 0x87: 8458 GETBYTE (); 8459 switch (op[2] & 0x00) 8460 { 8461 case 0x00: 8462 goto op_semantics_64; 8463 break; 8464 } 8465 break; 8466 case 0x88: 8467 GETBYTE (); 8468 switch (op[2] & 0x00) 8469 { 8470 case 0x00: 8471 op_semantics_65: 8472 { 8473 /** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */ 8474 #line 897 "rx-decode.opc" 8475 int sd AU = op[1] & 0x03; 8476 #line 897 "rx-decode.opc" 8477 int rsrc AU = (op[2] >> 4) & 0x0f; 8478 #line 897 "rx-decode.opc" 8479 int rdst AU = op[2] & 0x0f; 8480 if (trace) 8481 { 8482 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8483 "/** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */", 8484 op[0], op[1], op[2]); 8485 printf (" sd = 0x%x,", sd); 8486 printf (" rsrc = 0x%x,", rsrc); 8487 printf (" rdst = 0x%x\n", rdst); 8488 } 8489 SYNTAX("fadd %1%S1, %0"); 8490 #line 897 "rx-decode.opc" 8491 ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8492 8493 } 8494 break; 8495 } 8496 break; 8497 case 0x89: 8498 GETBYTE (); 8499 switch (op[2] & 0x00) 8500 { 8501 case 0x00: 8502 goto op_semantics_65; 8503 break; 8504 } 8505 break; 8506 case 0x8a: 8507 GETBYTE (); 8508 switch (op[2] & 0x00) 8509 { 8510 case 0x00: 8511 goto op_semantics_65; 8512 break; 8513 } 8514 break; 8515 case 0x8b: 8516 GETBYTE (); 8517 switch (op[2] & 0x00) 8518 { 8519 case 0x00: 8520 goto op_semantics_65; 8521 break; 8522 } 8523 break; 8524 case 0x8c: 8525 GETBYTE (); 8526 switch (op[2] & 0x00) 8527 { 8528 case 0x00: 8529 op_semantics_66: 8530 { 8531 /** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */ 8532 #line 918 "rx-decode.opc" 8533 int sd AU = op[1] & 0x03; 8534 #line 918 "rx-decode.opc" 8535 int rsrc AU = (op[2] >> 4) & 0x0f; 8536 #line 918 "rx-decode.opc" 8537 int rdst AU = op[2] & 0x0f; 8538 if (trace) 8539 { 8540 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8541 "/** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */", 8542 op[0], op[1], op[2]); 8543 printf (" sd = 0x%x,", sd); 8544 printf (" rsrc = 0x%x,", rsrc); 8545 printf (" rdst = 0x%x\n", rdst); 8546 } 8547 SYNTAX("fmul %1%S1, %0"); 8548 #line 918 "rx-decode.opc" 8549 ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8550 8551 } 8552 break; 8553 } 8554 break; 8555 case 0x8d: 8556 GETBYTE (); 8557 switch (op[2] & 0x00) 8558 { 8559 case 0x00: 8560 goto op_semantics_66; 8561 break; 8562 } 8563 break; 8564 case 0x8e: 8565 GETBYTE (); 8566 switch (op[2] & 0x00) 8567 { 8568 case 0x00: 8569 goto op_semantics_66; 8570 break; 8571 } 8572 break; 8573 case 0x8f: 8574 GETBYTE (); 8575 switch (op[2] & 0x00) 8576 { 8577 case 0x00: 8578 goto op_semantics_66; 8579 break; 8580 } 8581 break; 8582 case 0x90: 8583 GETBYTE (); 8584 switch (op[2] & 0x00) 8585 { 8586 case 0x00: 8587 op_semantics_67: 8588 { 8589 /** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */ 8590 #line 924 "rx-decode.opc" 8591 int sd AU = op[1] & 0x03; 8592 #line 924 "rx-decode.opc" 8593 int rsrc AU = (op[2] >> 4) & 0x0f; 8594 #line 924 "rx-decode.opc" 8595 int rdst AU = op[2] & 0x0f; 8596 if (trace) 8597 { 8598 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8599 "/** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */", 8600 op[0], op[1], op[2]); 8601 printf (" sd = 0x%x,", sd); 8602 printf (" rsrc = 0x%x,", rsrc); 8603 printf (" rdst = 0x%x\n", rdst); 8604 } 8605 SYNTAX("fdiv %1%S1, %0"); 8606 #line 924 "rx-decode.opc" 8607 ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8608 8609 } 8610 break; 8611 } 8612 break; 8613 case 0x91: 8614 GETBYTE (); 8615 switch (op[2] & 0x00) 8616 { 8617 case 0x00: 8618 goto op_semantics_67; 8619 break; 8620 } 8621 break; 8622 case 0x92: 8623 GETBYTE (); 8624 switch (op[2] & 0x00) 8625 { 8626 case 0x00: 8627 goto op_semantics_67; 8628 break; 8629 } 8630 break; 8631 case 0x93: 8632 GETBYTE (); 8633 switch (op[2] & 0x00) 8634 { 8635 case 0x00: 8636 goto op_semantics_67; 8637 break; 8638 } 8639 break; 8640 case 0x94: 8641 GETBYTE (); 8642 switch (op[2] & 0x00) 8643 { 8644 case 0x00: 8645 op_semantics_68: 8646 { 8647 /** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */ 8648 #line 912 "rx-decode.opc" 8649 int sd AU = op[1] & 0x03; 8650 #line 912 "rx-decode.opc" 8651 int rsrc AU = (op[2] >> 4) & 0x0f; 8652 #line 912 "rx-decode.opc" 8653 int rdst AU = op[2] & 0x0f; 8654 if (trace) 8655 { 8656 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8657 "/** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */", 8658 op[0], op[1], op[2]); 8659 printf (" sd = 0x%x,", sd); 8660 printf (" rsrc = 0x%x,", rsrc); 8661 printf (" rdst = 0x%x\n", rdst); 8662 } 8663 SYNTAX("ftoi %1%S1, %0"); 8664 #line 912 "rx-decode.opc" 8665 ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8666 8667 } 8668 break; 8669 } 8670 break; 8671 case 0x95: 8672 GETBYTE (); 8673 switch (op[2] & 0x00) 8674 { 8675 case 0x00: 8676 goto op_semantics_68; 8677 break; 8678 } 8679 break; 8680 case 0x96: 8681 GETBYTE (); 8682 switch (op[2] & 0x00) 8683 { 8684 case 0x00: 8685 goto op_semantics_68; 8686 break; 8687 } 8688 break; 8689 case 0x97: 8690 GETBYTE (); 8691 switch (op[2] & 0x00) 8692 { 8693 case 0x00: 8694 goto op_semantics_68; 8695 break; 8696 } 8697 break; 8698 case 0x98: 8699 GETBYTE (); 8700 switch (op[2] & 0x00) 8701 { 8702 case 0x00: 8703 op_semantics_69: 8704 { 8705 /** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */ 8706 #line 927 "rx-decode.opc" 8707 int sd AU = op[1] & 0x03; 8708 #line 927 "rx-decode.opc" 8709 int rsrc AU = (op[2] >> 4) & 0x0f; 8710 #line 927 "rx-decode.opc" 8711 int rdst AU = op[2] & 0x0f; 8712 if (trace) 8713 { 8714 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8715 "/** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */", 8716 op[0], op[1], op[2]); 8717 printf (" sd = 0x%x,", sd); 8718 printf (" rsrc = 0x%x,", rsrc); 8719 printf (" rdst = 0x%x\n", rdst); 8720 } 8721 SYNTAX("round %1%S1, %0"); 8722 #line 927 "rx-decode.opc" 8723 ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8724 8725 } 8726 break; 8727 } 8728 break; 8729 case 0x99: 8730 GETBYTE (); 8731 switch (op[2] & 0x00) 8732 { 8733 case 0x00: 8734 goto op_semantics_69; 8735 break; 8736 } 8737 break; 8738 case 0x9a: 8739 GETBYTE (); 8740 switch (op[2] & 0x00) 8741 { 8742 case 0x00: 8743 goto op_semantics_69; 8744 break; 8745 } 8746 break; 8747 case 0x9b: 8748 GETBYTE (); 8749 switch (op[2] & 0x00) 8750 { 8751 case 0x00: 8752 goto op_semantics_69; 8753 break; 8754 } 8755 break; 8756 case 0xa0: 8757 GETBYTE (); 8758 switch (op[2] & 0x00) 8759 { 8760 case 0x00: 8761 op_semantics_70: 8762 { 8763 /** 1111 1100 1010 00sd rsrc rdst fsqrt %1%S1, %0 */ 8764 #line 1110 "rx-decode.opc" 8765 int sd AU = op[1] & 0x03; 8766 #line 1110 "rx-decode.opc" 8767 int rsrc AU = (op[2] >> 4) & 0x0f; 8768 #line 1110 "rx-decode.opc" 8769 int rdst AU = op[2] & 0x0f; 8770 if (trace) 8771 { 8772 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8773 "/** 1111 1100 1010 00sd rsrc rdst fsqrt %1%S1, %0 */", 8774 op[0], op[1], op[2]); 8775 printf (" sd = 0x%x,", sd); 8776 printf (" rsrc = 0x%x,", rsrc); 8777 printf (" rdst = 0x%x\n", rdst); 8778 } 8779 SYNTAX("fsqrt %1%S1, %0"); 8780 #line 1110 "rx-decode.opc" 8781 ID(fsqrt); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8782 8783 } 8784 break; 8785 } 8786 break; 8787 case 0xa1: 8788 GETBYTE (); 8789 switch (op[2] & 0x00) 8790 { 8791 case 0x00: 8792 goto op_semantics_70; 8793 break; 8794 } 8795 break; 8796 case 0xa2: 8797 GETBYTE (); 8798 switch (op[2] & 0x00) 8799 { 8800 case 0x00: 8801 goto op_semantics_70; 8802 break; 8803 } 8804 break; 8805 case 0xa3: 8806 GETBYTE (); 8807 switch (op[2] & 0x00) 8808 { 8809 case 0x00: 8810 goto op_semantics_70; 8811 break; 8812 } 8813 break; 8814 case 0xa4: 8815 GETBYTE (); 8816 switch (op[2] & 0x00) 8817 { 8818 case 0x00: 8819 op_semantics_71: 8820 { 8821 /** 1111 1100 1010 01sd rsrc rdst ftou %1%S1, %0 */ 8822 #line 1113 "rx-decode.opc" 8823 int sd AU = op[1] & 0x03; 8824 #line 1113 "rx-decode.opc" 8825 int rsrc AU = (op[2] >> 4) & 0x0f; 8826 #line 1113 "rx-decode.opc" 8827 int rdst AU = op[2] & 0x0f; 8828 if (trace) 8829 { 8830 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8831 "/** 1111 1100 1010 01sd rsrc rdst ftou %1%S1, %0 */", 8832 op[0], op[1], op[2]); 8833 printf (" sd = 0x%x,", sd); 8834 printf (" rsrc = 0x%x,", rsrc); 8835 printf (" rdst = 0x%x\n", rdst); 8836 } 8837 SYNTAX("ftou %1%S1, %0"); 8838 #line 1113 "rx-decode.opc" 8839 ID(ftou); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8840 8841 } 8842 break; 8843 } 8844 break; 8845 case 0xa5: 8846 GETBYTE (); 8847 switch (op[2] & 0x00) 8848 { 8849 case 0x00: 8850 goto op_semantics_71; 8851 break; 8852 } 8853 break; 8854 case 0xa6: 8855 GETBYTE (); 8856 switch (op[2] & 0x00) 8857 { 8858 case 0x00: 8859 goto op_semantics_71; 8860 break; 8861 } 8862 break; 8863 case 0xa7: 8864 GETBYTE (); 8865 switch (op[2] & 0x00) 8866 { 8867 case 0x00: 8868 goto op_semantics_71; 8869 break; 8870 } 8871 break; 8872 case 0xd0: 8873 GETBYTE (); 8874 switch (op[2] & 0x00) 8875 { 8876 case 0x00: 8877 op_semantics_72: 8878 { 8879 /** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */ 8880 #line 1044 "rx-decode.opc" 8881 int sz AU = (op[1] >> 2) & 0x03; 8882 #line 1044 "rx-decode.opc" 8883 int sd AU = op[1] & 0x03; 8884 #line 1044 "rx-decode.opc" 8885 int rdst AU = (op[2] >> 4) & 0x0f; 8886 #line 1044 "rx-decode.opc" 8887 int cond AU = op[2] & 0x0f; 8888 if (trace) 8889 { 8890 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8891 "/** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */", 8892 op[0], op[1], op[2]); 8893 printf (" sz = 0x%x,", sz); 8894 printf (" sd = 0x%x,", sd); 8895 printf (" rdst = 0x%x,", rdst); 8896 printf (" cond = 0x%x\n", cond); 8897 } 8898 SYNTAX("sc%1%s %0"); 8899 #line 1044 "rx-decode.opc" 8900 ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond); 8901 8902 /*----------------------------------------------------------------------*/ 8903 /* RXv2 enhanced */ 8904 8905 } 8906 break; 8907 } 8908 break; 8909 case 0xd1: 8910 GETBYTE (); 8911 switch (op[2] & 0x00) 8912 { 8913 case 0x00: 8914 goto op_semantics_72; 8915 break; 8916 } 8917 break; 8918 case 0xd2: 8919 GETBYTE (); 8920 switch (op[2] & 0x00) 8921 { 8922 case 0x00: 8923 goto op_semantics_72; 8924 break; 8925 } 8926 break; 8927 case 0xd3: 8928 GETBYTE (); 8929 switch (op[2] & 0x00) 8930 { 8931 case 0x00: 8932 goto op_semantics_72; 8933 break; 8934 } 8935 break; 8936 case 0xd4: 8937 GETBYTE (); 8938 switch (op[2] & 0x00) 8939 { 8940 case 0x00: 8941 goto op_semantics_72; 8942 break; 8943 } 8944 break; 8945 case 0xd5: 8946 GETBYTE (); 8947 switch (op[2] & 0x00) 8948 { 8949 case 0x00: 8950 goto op_semantics_72; 8951 break; 8952 } 8953 break; 8954 case 0xd6: 8955 GETBYTE (); 8956 switch (op[2] & 0x00) 8957 { 8958 case 0x00: 8959 goto op_semantics_72; 8960 break; 8961 } 8962 break; 8963 case 0xd7: 8964 GETBYTE (); 8965 switch (op[2] & 0x00) 8966 { 8967 case 0x00: 8968 goto op_semantics_72; 8969 break; 8970 } 8971 break; 8972 case 0xd8: 8973 GETBYTE (); 8974 switch (op[2] & 0x00) 8975 { 8976 case 0x00: 8977 goto op_semantics_72; 8978 break; 8979 } 8980 break; 8981 case 0xd9: 8982 GETBYTE (); 8983 switch (op[2] & 0x00) 8984 { 8985 case 0x00: 8986 goto op_semantics_72; 8987 break; 8988 } 8989 break; 8990 case 0xda: 8991 GETBYTE (); 8992 switch (op[2] & 0x00) 8993 { 8994 case 0x00: 8995 goto op_semantics_72; 8996 break; 8997 } 8998 break; 8999 case 0xdb: 9000 GETBYTE (); 9001 switch (op[2] & 0x00) 9002 { 9003 case 0x00: 9004 goto op_semantics_72; 9005 break; 9006 } 9007 break; 9008 case 0xe0: 9009 GETBYTE (); 9010 switch (op[2] & 0x0f) 9011 { 9012 case 0x00: 9013 case 0x01: 9014 case 0x02: 9015 case 0x03: 9016 case 0x04: 9017 case 0x05: 9018 case 0x06: 9019 case 0x07: 9020 case 0x08: 9021 case 0x09: 9022 case 0x0a: 9023 case 0x0b: 9024 case 0x0c: 9025 case 0x0d: 9026 case 0x0e: 9027 op_semantics_73: 9028 { 9029 /** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */ 9030 #line 987 "rx-decode.opc" 9031 int bit AU = (op[1] >> 2) & 0x07; 9032 #line 987 "rx-decode.opc" 9033 int sd AU = op[1] & 0x03; 9034 #line 987 "rx-decode.opc" 9035 int rdst AU = (op[2] >> 4) & 0x0f; 9036 #line 987 "rx-decode.opc" 9037 int cond AU = op[2] & 0x0f; 9038 if (trace) 9039 { 9040 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9041 "/** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */", 9042 op[0], op[1], op[2]); 9043 printf (" bit = 0x%x,", bit); 9044 printf (" sd = 0x%x,", sd); 9045 printf (" rdst = 0x%x,", rdst); 9046 printf (" cond = 0x%x\n", cond); 9047 } 9048 SYNTAX("bm%2 #%1, %0%S0"); 9049 #line 987 "rx-decode.opc" 9050 ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE); 9051 9052 } 9053 break; 9054 case 0x0f: 9055 op_semantics_74: 9056 { 9057 /** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */ 9058 #line 975 "rx-decode.opc" 9059 int bit AU = (op[1] >> 2) & 0x07; 9060 #line 975 "rx-decode.opc" 9061 int sd AU = op[1] & 0x03; 9062 #line 975 "rx-decode.opc" 9063 int rdst AU = (op[2] >> 4) & 0x0f; 9064 if (trace) 9065 { 9066 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9067 "/** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */", 9068 op[0], op[1], op[2]); 9069 printf (" bit = 0x%x,", bit); 9070 printf (" sd = 0x%x,", sd); 9071 printf (" rdst = 0x%x\n", rdst); 9072 } 9073 SYNTAX("bnot #%1, %0%S0"); 9074 #line 975 "rx-decode.opc" 9075 ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); 9076 9077 } 9078 break; 9079 } 9080 break; 9081 case 0xe1: 9082 GETBYTE (); 9083 switch (op[2] & 0x0f) 9084 { 9085 case 0x00: 9086 case 0x01: 9087 case 0x02: 9088 case 0x03: 9089 case 0x04: 9090 case 0x05: 9091 case 0x06: 9092 case 0x07: 9093 case 0x08: 9094 case 0x09: 9095 case 0x0a: 9096 case 0x0b: 9097 case 0x0c: 9098 case 0x0d: 9099 case 0x0e: 9100 goto op_semantics_73; 9101 break; 9102 case 0x0f: 9103 goto op_semantics_74; 9104 break; 9105 } 9106 break; 9107 case 0xe2: 9108 GETBYTE (); 9109 switch (op[2] & 0x0f) 9110 { 9111 case 0x00: 9112 case 0x01: 9113 case 0x02: 9114 case 0x03: 9115 case 0x04: 9116 case 0x05: 9117 case 0x06: 9118 case 0x07: 9119 case 0x08: 9120 case 0x09: 9121 case 0x0a: 9122 case 0x0b: 9123 case 0x0c: 9124 case 0x0d: 9125 case 0x0e: 9126 goto op_semantics_73; 9127 break; 9128 case 0x0f: 9129 goto op_semantics_74; 9130 break; 9131 } 9132 break; 9133 case 0xe3: 9134 GETBYTE (); 9135 switch (op[2] & 0x0f) 9136 { 9137 case 0x00: 9138 case 0x01: 9139 case 0x02: 9140 case 0x03: 9141 case 0x04: 9142 case 0x05: 9143 case 0x06: 9144 case 0x07: 9145 case 0x08: 9146 case 0x09: 9147 case 0x0a: 9148 case 0x0b: 9149 case 0x0c: 9150 case 0x0d: 9151 case 0x0e: 9152 goto op_semantics_73; 9153 break; 9154 case 0x0f: 9155 goto op_semantics_74; 9156 break; 9157 } 9158 break; 9159 case 0xe4: 9160 GETBYTE (); 9161 switch (op[2] & 0x0f) 9162 { 9163 case 0x00: 9164 case 0x01: 9165 case 0x02: 9166 case 0x03: 9167 case 0x04: 9168 case 0x05: 9169 case 0x06: 9170 case 0x07: 9171 case 0x08: 9172 case 0x09: 9173 case 0x0a: 9174 case 0x0b: 9175 case 0x0c: 9176 case 0x0d: 9177 case 0x0e: 9178 goto op_semantics_73; 9179 break; 9180 case 0x0f: 9181 goto op_semantics_74; 9182 break; 9183 } 9184 break; 9185 case 0xe5: 9186 GETBYTE (); 9187 switch (op[2] & 0x0f) 9188 { 9189 case 0x00: 9190 case 0x01: 9191 case 0x02: 9192 case 0x03: 9193 case 0x04: 9194 case 0x05: 9195 case 0x06: 9196 case 0x07: 9197 case 0x08: 9198 case 0x09: 9199 case 0x0a: 9200 case 0x0b: 9201 case 0x0c: 9202 case 0x0d: 9203 case 0x0e: 9204 goto op_semantics_73; 9205 break; 9206 case 0x0f: 9207 goto op_semantics_74; 9208 break; 9209 } 9210 break; 9211 case 0xe6: 9212 GETBYTE (); 9213 switch (op[2] & 0x0f) 9214 { 9215 case 0x00: 9216 case 0x01: 9217 case 0x02: 9218 case 0x03: 9219 case 0x04: 9220 case 0x05: 9221 case 0x06: 9222 case 0x07: 9223 case 0x08: 9224 case 0x09: 9225 case 0x0a: 9226 case 0x0b: 9227 case 0x0c: 9228 case 0x0d: 9229 case 0x0e: 9230 goto op_semantics_73; 9231 break; 9232 case 0x0f: 9233 goto op_semantics_74; 9234 break; 9235 } 9236 break; 9237 case 0xe7: 9238 GETBYTE (); 9239 switch (op[2] & 0x0f) 9240 { 9241 case 0x00: 9242 case 0x01: 9243 case 0x02: 9244 case 0x03: 9245 case 0x04: 9246 case 0x05: 9247 case 0x06: 9248 case 0x07: 9249 case 0x08: 9250 case 0x09: 9251 case 0x0a: 9252 case 0x0b: 9253 case 0x0c: 9254 case 0x0d: 9255 case 0x0e: 9256 goto op_semantics_73; 9257 break; 9258 case 0x0f: 9259 goto op_semantics_74; 9260 break; 9261 } 9262 break; 9263 case 0xe8: 9264 GETBYTE (); 9265 switch (op[2] & 0x0f) 9266 { 9267 case 0x00: 9268 case 0x01: 9269 case 0x02: 9270 case 0x03: 9271 case 0x04: 9272 case 0x05: 9273 case 0x06: 9274 case 0x07: 9275 case 0x08: 9276 case 0x09: 9277 case 0x0a: 9278 case 0x0b: 9279 case 0x0c: 9280 case 0x0d: 9281 case 0x0e: 9282 goto op_semantics_73; 9283 break; 9284 case 0x0f: 9285 goto op_semantics_74; 9286 break; 9287 } 9288 break; 9289 case 0xe9: 9290 GETBYTE (); 9291 switch (op[2] & 0x0f) 9292 { 9293 case 0x00: 9294 case 0x01: 9295 case 0x02: 9296 case 0x03: 9297 case 0x04: 9298 case 0x05: 9299 case 0x06: 9300 case 0x07: 9301 case 0x08: 9302 case 0x09: 9303 case 0x0a: 9304 case 0x0b: 9305 case 0x0c: 9306 case 0x0d: 9307 case 0x0e: 9308 goto op_semantics_73; 9309 break; 9310 case 0x0f: 9311 goto op_semantics_74; 9312 break; 9313 } 9314 break; 9315 case 0xea: 9316 GETBYTE (); 9317 switch (op[2] & 0x0f) 9318 { 9319 case 0x00: 9320 case 0x01: 9321 case 0x02: 9322 case 0x03: 9323 case 0x04: 9324 case 0x05: 9325 case 0x06: 9326 case 0x07: 9327 case 0x08: 9328 case 0x09: 9329 case 0x0a: 9330 case 0x0b: 9331 case 0x0c: 9332 case 0x0d: 9333 case 0x0e: 9334 goto op_semantics_73; 9335 break; 9336 case 0x0f: 9337 goto op_semantics_74; 9338 break; 9339 } 9340 break; 9341 case 0xeb: 9342 GETBYTE (); 9343 switch (op[2] & 0x0f) 9344 { 9345 case 0x00: 9346 case 0x01: 9347 case 0x02: 9348 case 0x03: 9349 case 0x04: 9350 case 0x05: 9351 case 0x06: 9352 case 0x07: 9353 case 0x08: 9354 case 0x09: 9355 case 0x0a: 9356 case 0x0b: 9357 case 0x0c: 9358 case 0x0d: 9359 case 0x0e: 9360 goto op_semantics_73; 9361 break; 9362 case 0x0f: 9363 goto op_semantics_74; 9364 break; 9365 } 9366 break; 9367 case 0xec: 9368 GETBYTE (); 9369 switch (op[2] & 0x0f) 9370 { 9371 case 0x00: 9372 case 0x01: 9373 case 0x02: 9374 case 0x03: 9375 case 0x04: 9376 case 0x05: 9377 case 0x06: 9378 case 0x07: 9379 case 0x08: 9380 case 0x09: 9381 case 0x0a: 9382 case 0x0b: 9383 case 0x0c: 9384 case 0x0d: 9385 case 0x0e: 9386 goto op_semantics_73; 9387 break; 9388 case 0x0f: 9389 goto op_semantics_74; 9390 break; 9391 } 9392 break; 9393 case 0xed: 9394 GETBYTE (); 9395 switch (op[2] & 0x0f) 9396 { 9397 case 0x00: 9398 case 0x01: 9399 case 0x02: 9400 case 0x03: 9401 case 0x04: 9402 case 0x05: 9403 case 0x06: 9404 case 0x07: 9405 case 0x08: 9406 case 0x09: 9407 case 0x0a: 9408 case 0x0b: 9409 case 0x0c: 9410 case 0x0d: 9411 case 0x0e: 9412 goto op_semantics_73; 9413 break; 9414 case 0x0f: 9415 goto op_semantics_74; 9416 break; 9417 } 9418 break; 9419 case 0xee: 9420 GETBYTE (); 9421 switch (op[2] & 0x0f) 9422 { 9423 case 0x00: 9424 case 0x01: 9425 case 0x02: 9426 case 0x03: 9427 case 0x04: 9428 case 0x05: 9429 case 0x06: 9430 case 0x07: 9431 case 0x08: 9432 case 0x09: 9433 case 0x0a: 9434 case 0x0b: 9435 case 0x0c: 9436 case 0x0d: 9437 case 0x0e: 9438 goto op_semantics_73; 9439 break; 9440 case 0x0f: 9441 goto op_semantics_74; 9442 break; 9443 } 9444 break; 9445 case 0xef: 9446 GETBYTE (); 9447 switch (op[2] & 0x0f) 9448 { 9449 case 0x00: 9450 case 0x01: 9451 case 0x02: 9452 case 0x03: 9453 case 0x04: 9454 case 0x05: 9455 case 0x06: 9456 case 0x07: 9457 case 0x08: 9458 case 0x09: 9459 case 0x0a: 9460 case 0x0b: 9461 case 0x0c: 9462 case 0x0d: 9463 case 0x0e: 9464 goto op_semantics_73; 9465 break; 9466 case 0x0f: 9467 goto op_semantics_74; 9468 break; 9469 } 9470 break; 9471 case 0xf0: 9472 GETBYTE (); 9473 switch (op[2] & 0x0f) 9474 { 9475 case 0x00: 9476 case 0x01: 9477 case 0x02: 9478 case 0x03: 9479 case 0x04: 9480 case 0x05: 9481 case 0x06: 9482 case 0x07: 9483 case 0x08: 9484 case 0x09: 9485 case 0x0a: 9486 case 0x0b: 9487 case 0x0c: 9488 case 0x0d: 9489 case 0x0e: 9490 goto op_semantics_73; 9491 break; 9492 case 0x0f: 9493 goto op_semantics_74; 9494 break; 9495 } 9496 break; 9497 case 0xf1: 9498 GETBYTE (); 9499 switch (op[2] & 0x0f) 9500 { 9501 case 0x00: 9502 case 0x01: 9503 case 0x02: 9504 case 0x03: 9505 case 0x04: 9506 case 0x05: 9507 case 0x06: 9508 case 0x07: 9509 case 0x08: 9510 case 0x09: 9511 case 0x0a: 9512 case 0x0b: 9513 case 0x0c: 9514 case 0x0d: 9515 case 0x0e: 9516 goto op_semantics_73; 9517 break; 9518 case 0x0f: 9519 goto op_semantics_74; 9520 break; 9521 } 9522 break; 9523 case 0xf2: 9524 GETBYTE (); 9525 switch (op[2] & 0x0f) 9526 { 9527 case 0x00: 9528 case 0x01: 9529 case 0x02: 9530 case 0x03: 9531 case 0x04: 9532 case 0x05: 9533 case 0x06: 9534 case 0x07: 9535 case 0x08: 9536 case 0x09: 9537 case 0x0a: 9538 case 0x0b: 9539 case 0x0c: 9540 case 0x0d: 9541 case 0x0e: 9542 goto op_semantics_73; 9543 break; 9544 case 0x0f: 9545 goto op_semantics_74; 9546 break; 9547 } 9548 break; 9549 case 0xf3: 9550 GETBYTE (); 9551 switch (op[2] & 0x0f) 9552 { 9553 case 0x00: 9554 case 0x01: 9555 case 0x02: 9556 case 0x03: 9557 case 0x04: 9558 case 0x05: 9559 case 0x06: 9560 case 0x07: 9561 case 0x08: 9562 case 0x09: 9563 case 0x0a: 9564 case 0x0b: 9565 case 0x0c: 9566 case 0x0d: 9567 case 0x0e: 9568 goto op_semantics_73; 9569 break; 9570 case 0x0f: 9571 goto op_semantics_74; 9572 break; 9573 } 9574 break; 9575 case 0xf4: 9576 GETBYTE (); 9577 switch (op[2] & 0x0f) 9578 { 9579 case 0x00: 9580 case 0x01: 9581 case 0x02: 9582 case 0x03: 9583 case 0x04: 9584 case 0x05: 9585 case 0x06: 9586 case 0x07: 9587 case 0x08: 9588 case 0x09: 9589 case 0x0a: 9590 case 0x0b: 9591 case 0x0c: 9592 case 0x0d: 9593 case 0x0e: 9594 goto op_semantics_73; 9595 break; 9596 case 0x0f: 9597 goto op_semantics_74; 9598 break; 9599 } 9600 break; 9601 case 0xf5: 9602 GETBYTE (); 9603 switch (op[2] & 0x0f) 9604 { 9605 case 0x00: 9606 case 0x01: 9607 case 0x02: 9608 case 0x03: 9609 case 0x04: 9610 case 0x05: 9611 case 0x06: 9612 case 0x07: 9613 case 0x08: 9614 case 0x09: 9615 case 0x0a: 9616 case 0x0b: 9617 case 0x0c: 9618 case 0x0d: 9619 case 0x0e: 9620 goto op_semantics_73; 9621 break; 9622 case 0x0f: 9623 goto op_semantics_74; 9624 break; 9625 } 9626 break; 9627 case 0xf6: 9628 GETBYTE (); 9629 switch (op[2] & 0x0f) 9630 { 9631 case 0x00: 9632 case 0x01: 9633 case 0x02: 9634 case 0x03: 9635 case 0x04: 9636 case 0x05: 9637 case 0x06: 9638 case 0x07: 9639 case 0x08: 9640 case 0x09: 9641 case 0x0a: 9642 case 0x0b: 9643 case 0x0c: 9644 case 0x0d: 9645 case 0x0e: 9646 goto op_semantics_73; 9647 break; 9648 case 0x0f: 9649 goto op_semantics_74; 9650 break; 9651 } 9652 break; 9653 case 0xf7: 9654 GETBYTE (); 9655 switch (op[2] & 0x0f) 9656 { 9657 case 0x00: 9658 case 0x01: 9659 case 0x02: 9660 case 0x03: 9661 case 0x04: 9662 case 0x05: 9663 case 0x06: 9664 case 0x07: 9665 case 0x08: 9666 case 0x09: 9667 case 0x0a: 9668 case 0x0b: 9669 case 0x0c: 9670 case 0x0d: 9671 case 0x0e: 9672 goto op_semantics_73; 9673 break; 9674 case 0x0f: 9675 goto op_semantics_74; 9676 break; 9677 } 9678 break; 9679 case 0xf8: 9680 GETBYTE (); 9681 switch (op[2] & 0x0f) 9682 { 9683 case 0x00: 9684 case 0x01: 9685 case 0x02: 9686 case 0x03: 9687 case 0x04: 9688 case 0x05: 9689 case 0x06: 9690 case 0x07: 9691 case 0x08: 9692 case 0x09: 9693 case 0x0a: 9694 case 0x0b: 9695 case 0x0c: 9696 case 0x0d: 9697 case 0x0e: 9698 goto op_semantics_73; 9699 break; 9700 case 0x0f: 9701 goto op_semantics_74; 9702 break; 9703 } 9704 break; 9705 case 0xf9: 9706 GETBYTE (); 9707 switch (op[2] & 0x0f) 9708 { 9709 case 0x00: 9710 case 0x01: 9711 case 0x02: 9712 case 0x03: 9713 case 0x04: 9714 case 0x05: 9715 case 0x06: 9716 case 0x07: 9717 case 0x08: 9718 case 0x09: 9719 case 0x0a: 9720 case 0x0b: 9721 case 0x0c: 9722 case 0x0d: 9723 case 0x0e: 9724 goto op_semantics_73; 9725 break; 9726 case 0x0f: 9727 goto op_semantics_74; 9728 break; 9729 } 9730 break; 9731 case 0xfa: 9732 GETBYTE (); 9733 switch (op[2] & 0x0f) 9734 { 9735 case 0x00: 9736 case 0x01: 9737 case 0x02: 9738 case 0x03: 9739 case 0x04: 9740 case 0x05: 9741 case 0x06: 9742 case 0x07: 9743 case 0x08: 9744 case 0x09: 9745 case 0x0a: 9746 case 0x0b: 9747 case 0x0c: 9748 case 0x0d: 9749 case 0x0e: 9750 goto op_semantics_73; 9751 break; 9752 case 0x0f: 9753 goto op_semantics_74; 9754 break; 9755 } 9756 break; 9757 case 0xfb: 9758 GETBYTE (); 9759 switch (op[2] & 0x0f) 9760 { 9761 case 0x00: 9762 case 0x01: 9763 case 0x02: 9764 case 0x03: 9765 case 0x04: 9766 case 0x05: 9767 case 0x06: 9768 case 0x07: 9769 case 0x08: 9770 case 0x09: 9771 case 0x0a: 9772 case 0x0b: 9773 case 0x0c: 9774 case 0x0d: 9775 case 0x0e: 9776 goto op_semantics_73; 9777 break; 9778 case 0x0f: 9779 goto op_semantics_74; 9780 break; 9781 } 9782 break; 9783 case 0xfc: 9784 GETBYTE (); 9785 switch (op[2] & 0x0f) 9786 { 9787 case 0x00: 9788 case 0x01: 9789 case 0x02: 9790 case 0x03: 9791 case 0x04: 9792 case 0x05: 9793 case 0x06: 9794 case 0x07: 9795 case 0x08: 9796 case 0x09: 9797 case 0x0a: 9798 case 0x0b: 9799 case 0x0c: 9800 case 0x0d: 9801 case 0x0e: 9802 goto op_semantics_73; 9803 break; 9804 case 0x0f: 9805 goto op_semantics_74; 9806 break; 9807 } 9808 break; 9809 case 0xfd: 9810 GETBYTE (); 9811 switch (op[2] & 0x0f) 9812 { 9813 case 0x00: 9814 case 0x01: 9815 case 0x02: 9816 case 0x03: 9817 case 0x04: 9818 case 0x05: 9819 case 0x06: 9820 case 0x07: 9821 case 0x08: 9822 case 0x09: 9823 case 0x0a: 9824 case 0x0b: 9825 case 0x0c: 9826 case 0x0d: 9827 case 0x0e: 9828 goto op_semantics_73; 9829 break; 9830 case 0x0f: 9831 goto op_semantics_74; 9832 break; 9833 } 9834 break; 9835 case 0xfe: 9836 GETBYTE (); 9837 switch (op[2] & 0x0f) 9838 { 9839 case 0x00: 9840 case 0x01: 9841 case 0x02: 9842 case 0x03: 9843 case 0x04: 9844 case 0x05: 9845 case 0x06: 9846 case 0x07: 9847 case 0x08: 9848 case 0x09: 9849 case 0x0a: 9850 case 0x0b: 9851 case 0x0c: 9852 case 0x0d: 9853 case 0x0e: 9854 goto op_semantics_73; 9855 break; 9856 case 0x0f: 9857 goto op_semantics_74; 9858 break; 9859 } 9860 break; 9861 case 0xff: 9862 GETBYTE (); 9863 switch (op[2] & 0x0f) 9864 { 9865 case 0x00: 9866 case 0x01: 9867 case 0x02: 9868 case 0x03: 9869 case 0x04: 9870 case 0x05: 9871 case 0x06: 9872 case 0x07: 9873 case 0x08: 9874 case 0x09: 9875 case 0x0a: 9876 case 0x0b: 9877 case 0x0c: 9878 case 0x0d: 9879 case 0x0e: 9880 goto op_semantics_73; 9881 break; 9882 case 0x0f: 9883 goto op_semantics_74; 9884 break; 9885 } 9886 break; 9887 default: UNSUPPORTED(); break; 9888 } 9889 break; 9890 case 0xfd: 9891 GETBYTE (); 9892 switch (op[1] & 0xff) 9893 { 9894 case 0x00: 9895 GETBYTE (); 9896 switch (op[2] & 0x00) 9897 { 9898 case 0x00: 9899 op_semantics_75: 9900 { 9901 /** 1111 1101 0000 a000 srca srcb mulhi %1, %2, %0 */ 9902 #line 852 "rx-decode.opc" 9903 int a AU = (op[1] >> 3) & 0x01; 9904 #line 852 "rx-decode.opc" 9905 int srca AU = (op[2] >> 4) & 0x0f; 9906 #line 852 "rx-decode.opc" 9907 int srcb AU = op[2] & 0x0f; 9908 if (trace) 9909 { 9910 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9911 "/** 1111 1101 0000 a000 srca srcb mulhi %1, %2, %0 */", 9912 op[0], op[1], op[2]); 9913 printf (" a = 0x%x,", a); 9914 printf (" srca = 0x%x,", srca); 9915 printf (" srcb = 0x%x\n", srcb); 9916 } 9917 SYNTAX("mulhi %1, %2, %0"); 9918 #line 852 "rx-decode.opc" 9919 ID(mulhi); DR(a+32); SR(srca); S2R(srcb); F_____; 9920 9921 } 9922 break; 9923 } 9924 break; 9925 case 0x01: 9926 GETBYTE (); 9927 switch (op[2] & 0x00) 9928 { 9929 case 0x00: 9930 op_semantics_76: 9931 { 9932 /** 1111 1101 0000 a001 srca srcb mullo %1, %2, %0 */ 9933 #line 855 "rx-decode.opc" 9934 int a AU = (op[1] >> 3) & 0x01; 9935 #line 855 "rx-decode.opc" 9936 int srca AU = (op[2] >> 4) & 0x0f; 9937 #line 855 "rx-decode.opc" 9938 int srcb AU = op[2] & 0x0f; 9939 if (trace) 9940 { 9941 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9942 "/** 1111 1101 0000 a001 srca srcb mullo %1, %2, %0 */", 9943 op[0], op[1], op[2]); 9944 printf (" a = 0x%x,", a); 9945 printf (" srca = 0x%x,", srca); 9946 printf (" srcb = 0x%x\n", srcb); 9947 } 9948 SYNTAX("mullo %1, %2, %0"); 9949 #line 855 "rx-decode.opc" 9950 ID(mullo); DR(a+32); SR(srca); S2R(srcb); F_____; 9951 9952 } 9953 break; 9954 } 9955 break; 9956 case 0x02: 9957 GETBYTE (); 9958 switch (op[2] & 0x00) 9959 { 9960 case 0x00: 9961 op_semantics_77: 9962 { 9963 /** 1111 1101 0000 a010 srca srcb mullh %1, %2, %0 */ 9964 #line 1083 "rx-decode.opc" 9965 int a AU = (op[1] >> 3) & 0x01; 9966 #line 1083 "rx-decode.opc" 9967 int srca AU = (op[2] >> 4) & 0x0f; 9968 #line 1083 "rx-decode.opc" 9969 int srcb AU = op[2] & 0x0f; 9970 if (trace) 9971 { 9972 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9973 "/** 1111 1101 0000 a010 srca srcb mullh %1, %2, %0 */", 9974 op[0], op[1], op[2]); 9975 printf (" a = 0x%x,", a); 9976 printf (" srca = 0x%x,", srca); 9977 printf (" srcb = 0x%x\n", srcb); 9978 } 9979 SYNTAX("mullh %1, %2, %0"); 9980 #line 1083 "rx-decode.opc" 9981 ID(mullh); DR(a+32); SR(srca); S2R(srcb); F_____; 9982 9983 } 9984 break; 9985 } 9986 break; 9987 case 0x03: 9988 GETBYTE (); 9989 switch (op[2] & 0x00) 9990 { 9991 case 0x00: 9992 op_semantics_78: 9993 { 9994 /** 1111 1101 0000 a011 srca srcb emula %1, %2, %0 */ 9995 #line 1068 "rx-decode.opc" 9996 int a AU = (op[1] >> 3) & 0x01; 9997 #line 1068 "rx-decode.opc" 9998 int srca AU = (op[2] >> 4) & 0x0f; 9999 #line 1068 "rx-decode.opc" 10000 int srcb AU = op[2] & 0x0f; 10001 if (trace) 10002 { 10003 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10004 "/** 1111 1101 0000 a011 srca srcb emula %1, %2, %0 */", 10005 op[0], op[1], op[2]); 10006 printf (" a = 0x%x,", a); 10007 printf (" srca = 0x%x,", srca); 10008 printf (" srcb = 0x%x\n", srcb); 10009 } 10010 SYNTAX("emula %1, %2, %0"); 10011 #line 1068 "rx-decode.opc" 10012 ID(emula); DR(a+32); SR(srca); S2R(srcb); F_____; 10013 10014 } 10015 break; 10016 } 10017 break; 10018 case 0x04: 10019 GETBYTE (); 10020 switch (op[2] & 0x00) 10021 { 10022 case 0x00: 10023 op_semantics_79: 10024 { 10025 /** 1111 1101 0000 a100 srca srcb machi %1, %2, %0 */ 10026 #line 858 "rx-decode.opc" 10027 int a AU = (op[1] >> 3) & 0x01; 10028 #line 858 "rx-decode.opc" 10029 int srca AU = (op[2] >> 4) & 0x0f; 10030 #line 858 "rx-decode.opc" 10031 int srcb AU = op[2] & 0x0f; 10032 if (trace) 10033 { 10034 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10035 "/** 1111 1101 0000 a100 srca srcb machi %1, %2, %0 */", 10036 op[0], op[1], op[2]); 10037 printf (" a = 0x%x,", a); 10038 printf (" srca = 0x%x,", srca); 10039 printf (" srcb = 0x%x\n", srcb); 10040 } 10041 SYNTAX("machi %1, %2, %0"); 10042 #line 858 "rx-decode.opc" 10043 ID(machi); DR(a+32); SR(srca); S2R(srcb); F_____; 10044 10045 } 10046 break; 10047 } 10048 break; 10049 case 0x05: 10050 GETBYTE (); 10051 switch (op[2] & 0x00) 10052 { 10053 case 0x00: 10054 op_semantics_80: 10055 { 10056 /** 1111 1101 0000 a101 srca srcb maclo %1, %2, %0 */ 10057 #line 861 "rx-decode.opc" 10058 int a AU = (op[1] >> 3) & 0x01; 10059 #line 861 "rx-decode.opc" 10060 int srca AU = (op[2] >> 4) & 0x0f; 10061 #line 861 "rx-decode.opc" 10062 int srcb AU = op[2] & 0x0f; 10063 if (trace) 10064 { 10065 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10066 "/** 1111 1101 0000 a101 srca srcb maclo %1, %2, %0 */", 10067 op[0], op[1], op[2]); 10068 printf (" a = 0x%x,", a); 10069 printf (" srca = 0x%x,", srca); 10070 printf (" srcb = 0x%x\n", srcb); 10071 } 10072 SYNTAX("maclo %1, %2, %0"); 10073 #line 861 "rx-decode.opc" 10074 ID(maclo); DR(a+32); SR(srca); S2R(srcb); F_____; 10075 10076 } 10077 break; 10078 } 10079 break; 10080 case 0x06: 10081 GETBYTE (); 10082 switch (op[2] & 0x00) 10083 { 10084 case 0x00: 10085 op_semantics_81: 10086 { 10087 /** 1111 1101 0000 a110 srca srcb maclh %1, %2, %0 */ 10088 #line 1071 "rx-decode.opc" 10089 int a AU = (op[1] >> 3) & 0x01; 10090 #line 1071 "rx-decode.opc" 10091 int srca AU = (op[2] >> 4) & 0x0f; 10092 #line 1071 "rx-decode.opc" 10093 int srcb AU = op[2] & 0x0f; 10094 if (trace) 10095 { 10096 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10097 "/** 1111 1101 0000 a110 srca srcb maclh %1, %2, %0 */", 10098 op[0], op[1], op[2]); 10099 printf (" a = 0x%x,", a); 10100 printf (" srca = 0x%x,", srca); 10101 printf (" srcb = 0x%x\n", srcb); 10102 } 10103 SYNTAX("maclh %1, %2, %0"); 10104 #line 1071 "rx-decode.opc" 10105 ID(maclh); DR(a+32); SR(srca); S2R(srcb); F_____; 10106 10107 } 10108 break; 10109 } 10110 break; 10111 case 0x07: 10112 GETBYTE (); 10113 switch (op[2] & 0x00) 10114 { 10115 case 0x00: 10116 op_semantics_82: 10117 { 10118 /** 1111 1101 0000 a111 srca srcb emaca %1, %2, %0 */ 10119 #line 1062 "rx-decode.opc" 10120 int a AU = (op[1] >> 3) & 0x01; 10121 #line 1062 "rx-decode.opc" 10122 int srca AU = (op[2] >> 4) & 0x0f; 10123 #line 1062 "rx-decode.opc" 10124 int srcb AU = op[2] & 0x0f; 10125 if (trace) 10126 { 10127 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10128 "/** 1111 1101 0000 a111 srca srcb emaca %1, %2, %0 */", 10129 op[0], op[1], op[2]); 10130 printf (" a = 0x%x,", a); 10131 printf (" srca = 0x%x,", srca); 10132 printf (" srcb = 0x%x\n", srcb); 10133 } 10134 SYNTAX("emaca %1, %2, %0"); 10135 #line 1062 "rx-decode.opc" 10136 ID(emaca); DR(a+32); SR(srca); S2R(srcb); F_____; 10137 10138 } 10139 break; 10140 } 10141 break; 10142 case 0x08: 10143 GETBYTE (); 10144 switch (op[2] & 0x00) 10145 { 10146 case 0x00: 10147 goto op_semantics_75; 10148 break; 10149 } 10150 break; 10151 case 0x09: 10152 GETBYTE (); 10153 switch (op[2] & 0x00) 10154 { 10155 case 0x00: 10156 goto op_semantics_76; 10157 break; 10158 } 10159 break; 10160 case 0x0a: 10161 GETBYTE (); 10162 switch (op[2] & 0x00) 10163 { 10164 case 0x00: 10165 goto op_semantics_77; 10166 break; 10167 } 10168 break; 10169 case 0x0b: 10170 GETBYTE (); 10171 switch (op[2] & 0x00) 10172 { 10173 case 0x00: 10174 goto op_semantics_78; 10175 break; 10176 } 10177 break; 10178 case 0x0c: 10179 GETBYTE (); 10180 switch (op[2] & 0x00) 10181 { 10182 case 0x00: 10183 goto op_semantics_79; 10184 break; 10185 } 10186 break; 10187 case 0x0d: 10188 GETBYTE (); 10189 switch (op[2] & 0x00) 10190 { 10191 case 0x00: 10192 goto op_semantics_80; 10193 break; 10194 } 10195 break; 10196 case 0x0e: 10197 GETBYTE (); 10198 switch (op[2] & 0x00) 10199 { 10200 case 0x00: 10201 goto op_semantics_81; 10202 break; 10203 } 10204 break; 10205 case 0x0f: 10206 GETBYTE (); 10207 switch (op[2] & 0x00) 10208 { 10209 case 0x00: 10210 goto op_semantics_82; 10211 break; 10212 } 10213 break; 10214 case 0x17: 10215 GETBYTE (); 10216 switch (op[2] & 0x70) 10217 { 10218 case 0x00: 10219 { 10220 /** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */ 10221 #line 864 "rx-decode.opc" 10222 int a AU = (op[2] >> 7) & 0x01; 10223 #line 864 "rx-decode.opc" 10224 int rsrc AU = op[2] & 0x0f; 10225 if (trace) 10226 { 10227 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10228 "/** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */", 10229 op[0], op[1], op[2]); 10230 printf (" a = 0x%x,", a); 10231 printf (" rsrc = 0x%x\n", rsrc); 10232 } 10233 SYNTAX("mvtachi %1, %0"); 10234 #line 864 "rx-decode.opc" 10235 ID(mvtachi); DR(a+32); SR(rsrc); F_____; 10236 10237 } 10238 break; 10239 case 0x10: 10240 { 10241 /** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */ 10242 #line 867 "rx-decode.opc" 10243 int a AU = (op[2] >> 7) & 0x01; 10244 #line 867 "rx-decode.opc" 10245 int rsrc AU = op[2] & 0x0f; 10246 if (trace) 10247 { 10248 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10249 "/** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */", 10250 op[0], op[1], op[2]); 10251 printf (" a = 0x%x,", a); 10252 printf (" rsrc = 0x%x\n", rsrc); 10253 } 10254 SYNTAX("mvtaclo %1, %0"); 10255 #line 867 "rx-decode.opc" 10256 ID(mvtaclo); DR(a+32); SR(rsrc); F_____; 10257 10258 } 10259 break; 10260 case 0x30: 10261 { 10262 /** 1111 1101 0001 0111 a011 rdst mvtacgu %0, %1 */ 10263 #line 1089 "rx-decode.opc" 10264 int a AU = (op[2] >> 7) & 0x01; 10265 #line 1089 "rx-decode.opc" 10266 int rdst AU = op[2] & 0x0f; 10267 if (trace) 10268 { 10269 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10270 "/** 1111 1101 0001 0111 a011 rdst mvtacgu %0, %1 */", 10271 op[0], op[1], op[2]); 10272 printf (" a = 0x%x,", a); 10273 printf (" rdst = 0x%x\n", rdst); 10274 } 10275 SYNTAX("mvtacgu %0, %1"); 10276 #line 1089 "rx-decode.opc" 10277 ID(mvtacgu); DR(a+32); SR(rdst); F_____; 10278 10279 } 10280 break; 10281 default: UNSUPPORTED(); break; 10282 } 10283 break; 10284 case 0x18: 10285 GETBYTE (); 10286 switch (op[2] & 0x6f) 10287 { 10288 case 0x00: 10289 { 10290 /** 1111 1101 0001 1000 a00i 0000 racw #%1, %0 */ 10291 #line 879 "rx-decode.opc" 10292 int a AU = (op[2] >> 7) & 0x01; 10293 #line 879 "rx-decode.opc" 10294 int i AU = (op[2] >> 4) & 0x01; 10295 if (trace) 10296 { 10297 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10298 "/** 1111 1101 0001 1000 a00i 0000 racw #%1, %0 */", 10299 op[0], op[1], op[2]); 10300 printf (" a = 0x%x,", a); 10301 printf (" i = 0x%x\n", i); 10302 } 10303 SYNTAX("racw #%1, %0"); 10304 #line 879 "rx-decode.opc" 10305 ID(racw); SC(i+1); DR(a+32); F_____; 10306 10307 /*----------------------------------------------------------------------*/ 10308 /* SAT */ 10309 10310 } 10311 break; 10312 case 0x40: 10313 { 10314 /** 1111 1101 0001 1000 a10i 0000 rdacw #%1, %0 */ 10315 #line 1098 "rx-decode.opc" 10316 int a AU = (op[2] >> 7) & 0x01; 10317 #line 1098 "rx-decode.opc" 10318 int i AU = (op[2] >> 4) & 0x01; 10319 if (trace) 10320 { 10321 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10322 "/** 1111 1101 0001 1000 a10i 0000 rdacw #%1, %0 */", 10323 op[0], op[1], op[2]); 10324 printf (" a = 0x%x,", a); 10325 printf (" i = 0x%x\n", i); 10326 } 10327 SYNTAX("rdacw #%1, %0"); 10328 #line 1098 "rx-decode.opc" 10329 ID(rdacw); SC(i+1); DR(a+32); F_____; 10330 10331 } 10332 break; 10333 default: UNSUPPORTED(); break; 10334 } 10335 break; 10336 case 0x19: 10337 GETBYTE (); 10338 switch (op[2] & 0x6f) 10339 { 10340 case 0x00: 10341 { 10342 /** 1111 1101 0001 1001 a00i 0000 racl #%1, %0 */ 10343 #line 1092 "rx-decode.opc" 10344 int a AU = (op[2] >> 7) & 0x01; 10345 #line 1092 "rx-decode.opc" 10346 int i AU = (op[2] >> 4) & 0x01; 10347 if (trace) 10348 { 10349 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10350 "/** 1111 1101 0001 1001 a00i 0000 racl #%1, %0 */", 10351 op[0], op[1], op[2]); 10352 printf (" a = 0x%x,", a); 10353 printf (" i = 0x%x\n", i); 10354 } 10355 SYNTAX("racl #%1, %0"); 10356 #line 1092 "rx-decode.opc" 10357 ID(racl); SC(i+1); DR(a+32); F_____; 10358 10359 } 10360 break; 10361 case 0x40: 10362 { 10363 /** 1111 1101 0001 1001 a10i 0000 rdacl #%1, %0 */ 10364 #line 1095 "rx-decode.opc" 10365 int a AU = (op[2] >> 7) & 0x01; 10366 #line 1095 "rx-decode.opc" 10367 int i AU = (op[2] >> 4) & 0x01; 10368 if (trace) 10369 { 10370 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10371 "/** 1111 1101 0001 1001 a10i 0000 rdacl #%1, %0 */", 10372 op[0], op[1], op[2]); 10373 printf (" a = 0x%x,", a); 10374 printf (" i = 0x%x\n", i); 10375 } 10376 SYNTAX("rdacl #%1, %0"); 10377 #line 1095 "rx-decode.opc" 10378 ID(rdacl); SC(i+1); DR(a+32); F_____; 10379 10380 } 10381 break; 10382 default: UNSUPPORTED(); break; 10383 } 10384 break; 10385 case 0x1e: 10386 GETBYTE (); 10387 switch (op[2] & 0x30) 10388 { 10389 case 0x00: 10390 op_semantics_83: 10391 { 10392 /** 1111 1101 0001 111i a m00 rdst mvfachi #%2, %1, %0 */ 10393 #line 870 "rx-decode.opc" 10394 int i AU = op[1] & 0x01; 10395 #line 870 "rx-decode.opc" 10396 int a AU = (op[2] >> 7) & 0x01; 10397 #line 870 "rx-decode.opc" 10398 int m AU = (op[2] >> 6) & 0x01; 10399 #line 870 "rx-decode.opc" 10400 int rdst AU = op[2] & 0x0f; 10401 if (trace) 10402 { 10403 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10404 "/** 1111 1101 0001 111i a m00 rdst mvfachi #%2, %1, %0 */", 10405 op[0], op[1], op[2]); 10406 printf (" i = 0x%x,", i); 10407 printf (" a = 0x%x,", a); 10408 printf (" m = 0x%x,", m); 10409 printf (" rdst = 0x%x\n", rdst); 10410 } 10411 SYNTAX("mvfachi #%2, %1, %0"); 10412 #line 870 "rx-decode.opc" 10413 ID(mvfachi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____; 10414 10415 } 10416 break; 10417 case 0x10: 10418 op_semantics_84: 10419 { 10420 /** 1111 1101 0001 111i a m01 rdst mvfaclo #%2, %1, %0 */ 10421 #line 876 "rx-decode.opc" 10422 int i AU = op[1] & 0x01; 10423 #line 876 "rx-decode.opc" 10424 int a AU = (op[2] >> 7) & 0x01; 10425 #line 876 "rx-decode.opc" 10426 int m AU = (op[2] >> 6) & 0x01; 10427 #line 876 "rx-decode.opc" 10428 int rdst AU = op[2] & 0x0f; 10429 if (trace) 10430 { 10431 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10432 "/** 1111 1101 0001 111i a m01 rdst mvfaclo #%2, %1, %0 */", 10433 op[0], op[1], op[2]); 10434 printf (" i = 0x%x,", i); 10435 printf (" a = 0x%x,", a); 10436 printf (" m = 0x%x,", m); 10437 printf (" rdst = 0x%x\n", rdst); 10438 } 10439 SYNTAX("mvfaclo #%2, %1, %0"); 10440 #line 876 "rx-decode.opc" 10441 ID(mvfaclo); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____; 10442 10443 } 10444 break; 10445 case 0x20: 10446 op_semantics_85: 10447 { 10448 /** 1111 1101 0001 111i a m10 rdst mvfacmi #%2, %1, %0 */ 10449 #line 873 "rx-decode.opc" 10450 int i AU = op[1] & 0x01; 10451 #line 873 "rx-decode.opc" 10452 int a AU = (op[2] >> 7) & 0x01; 10453 #line 873 "rx-decode.opc" 10454 int m AU = (op[2] >> 6) & 0x01; 10455 #line 873 "rx-decode.opc" 10456 int rdst AU = op[2] & 0x0f; 10457 if (trace) 10458 { 10459 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10460 "/** 1111 1101 0001 111i a m10 rdst mvfacmi #%2, %1, %0 */", 10461 op[0], op[1], op[2]); 10462 printf (" i = 0x%x,", i); 10463 printf (" a = 0x%x,", a); 10464 printf (" m = 0x%x,", m); 10465 printf (" rdst = 0x%x\n", rdst); 10466 } 10467 SYNTAX("mvfacmi #%2, %1, %0"); 10468 #line 873 "rx-decode.opc" 10469 ID(mvfacmi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____; 10470 10471 } 10472 break; 10473 case 0x30: 10474 op_semantics_86: 10475 { 10476 /** 1111 1101 0001 111i a m11 rdst mvfacgu #%2, %1, %0 */ 10477 #line 1086 "rx-decode.opc" 10478 int i AU = op[1] & 0x01; 10479 #line 1086 "rx-decode.opc" 10480 int a AU = (op[2] >> 7) & 0x01; 10481 #line 1086 "rx-decode.opc" 10482 int m AU = (op[2] >> 6) & 0x01; 10483 #line 1086 "rx-decode.opc" 10484 int rdst AU = op[2] & 0x0f; 10485 if (trace) 10486 { 10487 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10488 "/** 1111 1101 0001 111i a m11 rdst mvfacgu #%2, %1, %0 */", 10489 op[0], op[1], op[2]); 10490 printf (" i = 0x%x,", i); 10491 printf (" a = 0x%x,", a); 10492 printf (" m = 0x%x,", m); 10493 printf (" rdst = 0x%x\n", rdst); 10494 } 10495 SYNTAX("mvfacgu #%2, %1, %0"); 10496 #line 1086 "rx-decode.opc" 10497 ID(mvfacgu); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____; 10498 10499 } 10500 break; 10501 } 10502 break; 10503 case 0x1f: 10504 GETBYTE (); 10505 switch (op[2] & 0x30) 10506 { 10507 case 0x00: 10508 goto op_semantics_83; 10509 break; 10510 case 0x10: 10511 goto op_semantics_84; 10512 break; 10513 case 0x20: 10514 goto op_semantics_85; 10515 break; 10516 case 0x30: 10517 goto op_semantics_86; 10518 break; 10519 } 10520 break; 10521 case 0x20: 10522 GETBYTE (); 10523 switch (op[2] & 0x00) 10524 { 10525 case 0x00: 10526 op_semantics_87: 10527 { 10528 /** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */ 10529 #line 348 "rx-decode.opc" 10530 int p AU = (op[1] >> 2) & 0x01; 10531 #line 348 "rx-decode.opc" 10532 int sz AU = op[1] & 0x03; 10533 #line 348 "rx-decode.opc" 10534 int rdst AU = (op[2] >> 4) & 0x0f; 10535 #line 348 "rx-decode.opc" 10536 int rsrc AU = op[2] & 0x0f; 10537 if (trace) 10538 { 10539 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10540 "/** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */", 10541 op[0], op[1], op[2]); 10542 printf (" p = 0x%x,", p); 10543 printf (" sz = 0x%x,", sz); 10544 printf (" rdst = 0x%x,", rdst); 10545 printf (" rsrc = 0x%x\n", rsrc); 10546 } 10547 SYNTAX("mov%s %1, %0"); 10548 #line 348 "rx-decode.opc" 10549 ID(mov); sBWL (sz); SR(rsrc); F_____; 10550 OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0); 10551 10552 } 10553 break; 10554 } 10555 break; 10556 case 0x21: 10557 GETBYTE (); 10558 switch (op[2] & 0x00) 10559 { 10560 case 0x00: 10561 goto op_semantics_87; 10562 break; 10563 } 10564 break; 10565 case 0x22: 10566 GETBYTE (); 10567 switch (op[2] & 0x00) 10568 { 10569 case 0x00: 10570 goto op_semantics_87; 10571 break; 10572 } 10573 break; 10574 case 0x24: 10575 GETBYTE (); 10576 switch (op[2] & 0x00) 10577 { 10578 case 0x00: 10579 goto op_semantics_87; 10580 break; 10581 } 10582 break; 10583 case 0x25: 10584 GETBYTE (); 10585 switch (op[2] & 0x00) 10586 { 10587 case 0x00: 10588 goto op_semantics_87; 10589 break; 10590 } 10591 break; 10592 case 0x26: 10593 GETBYTE (); 10594 switch (op[2] & 0x00) 10595 { 10596 case 0x00: 10597 goto op_semantics_87; 10598 break; 10599 } 10600 break; 10601 case 0x27: 10602 GETBYTE (); 10603 switch (op[2] & 0x00) 10604 { 10605 case 0x00: 10606 { 10607 /** 1111 1101 0010 0111 rdst rsrc movco %1, [%0] */ 10608 #line 1050 "rx-decode.opc" 10609 int rdst AU = (op[2] >> 4) & 0x0f; 10610 #line 1050 "rx-decode.opc" 10611 int rsrc AU = op[2] & 0x0f; 10612 if (trace) 10613 { 10614 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10615 "/** 1111 1101 0010 0111 rdst rsrc movco %1, [%0] */", 10616 op[0], op[1], op[2]); 10617 printf (" rdst = 0x%x,", rdst); 10618 printf (" rsrc = 0x%x\n", rsrc); 10619 } 10620 SYNTAX("movco %1, [%0]"); 10621 #line 1050 "rx-decode.opc" 10622 ID(movco); SR(rsrc); DR(rdst); F_____; 10623 10624 } 10625 break; 10626 } 10627 break; 10628 case 0x28: 10629 GETBYTE (); 10630 switch (op[2] & 0x00) 10631 { 10632 case 0x00: 10633 op_semantics_88: 10634 { 10635 /** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */ 10636 #line 352 "rx-decode.opc" 10637 int p AU = (op[1] >> 2) & 0x01; 10638 #line 352 "rx-decode.opc" 10639 int sz AU = op[1] & 0x03; 10640 #line 352 "rx-decode.opc" 10641 int rsrc AU = (op[2] >> 4) & 0x0f; 10642 #line 352 "rx-decode.opc" 10643 int rdst AU = op[2] & 0x0f; 10644 if (trace) 10645 { 10646 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10647 "/** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */", 10648 op[0], op[1], op[2]); 10649 printf (" p = 0x%x,", p); 10650 printf (" sz = 0x%x,", sz); 10651 printf (" rsrc = 0x%x,", rsrc); 10652 printf (" rdst = 0x%x\n", rdst); 10653 } 10654 SYNTAX("mov%s %1, %0"); 10655 #line 352 "rx-decode.opc" 10656 ID(mov); sBWL (sz); DR(rdst); F_____; 10657 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0); 10658 10659 } 10660 break; 10661 } 10662 break; 10663 case 0x29: 10664 GETBYTE (); 10665 switch (op[2] & 0x00) 10666 { 10667 case 0x00: 10668 goto op_semantics_88; 10669 break; 10670 } 10671 break; 10672 case 0x2a: 10673 GETBYTE (); 10674 switch (op[2] & 0x00) 10675 { 10676 case 0x00: 10677 goto op_semantics_88; 10678 break; 10679 } 10680 break; 10681 case 0x2c: 10682 GETBYTE (); 10683 switch (op[2] & 0x00) 10684 { 10685 case 0x00: 10686 goto op_semantics_88; 10687 break; 10688 } 10689 break; 10690 case 0x2d: 10691 GETBYTE (); 10692 switch (op[2] & 0x00) 10693 { 10694 case 0x00: 10695 goto op_semantics_88; 10696 break; 10697 } 10698 break; 10699 case 0x2e: 10700 GETBYTE (); 10701 switch (op[2] & 0x00) 10702 { 10703 case 0x00: 10704 goto op_semantics_88; 10705 break; 10706 } 10707 break; 10708 case 0x2f: 10709 GETBYTE (); 10710 switch (op[2] & 0x00) 10711 { 10712 case 0x00: 10713 { 10714 /** 1111 1101 0010 1111 rsrc rdst movli [%1], %0 */ 10715 #line 1053 "rx-decode.opc" 10716 int rsrc AU = (op[2] >> 4) & 0x0f; 10717 #line 1053 "rx-decode.opc" 10718 int rdst AU = op[2] & 0x0f; 10719 if (trace) 10720 { 10721 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10722 "/** 1111 1101 0010 1111 rsrc rdst movli [%1], %0 */", 10723 op[0], op[1], op[2]); 10724 printf (" rsrc = 0x%x,", rsrc); 10725 printf (" rdst = 0x%x\n", rdst); 10726 } 10727 SYNTAX("movli [%1], %0"); 10728 #line 1053 "rx-decode.opc" 10729 ID(movli); SR(rsrc); DR(rdst); F_____; 10730 10731 } 10732 break; 10733 } 10734 break; 10735 case 0x38: 10736 GETBYTE (); 10737 switch (op[2] & 0x00) 10738 { 10739 case 0x00: 10740 op_semantics_89: 10741 { 10742 /** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */ 10743 #line 362 "rx-decode.opc" 10744 int p AU = (op[1] >> 2) & 0x01; 10745 #line 362 "rx-decode.opc" 10746 int sz AU = op[1] & 0x03; 10747 #line 362 "rx-decode.opc" 10748 int rsrc AU = (op[2] >> 4) & 0x0f; 10749 #line 362 "rx-decode.opc" 10750 int rdst AU = op[2] & 0x0f; 10751 if (trace) 10752 { 10753 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10754 "/** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */", 10755 op[0], op[1], op[2]); 10756 printf (" p = 0x%x,", p); 10757 printf (" sz = 0x%x,", sz); 10758 printf (" rsrc = 0x%x,", rsrc); 10759 printf (" rdst = 0x%x\n", rdst); 10760 } 10761 SYNTAX("movu%s %1, %0"); 10762 #line 362 "rx-decode.opc" 10763 ID(mov); uBW (sz); DR(rdst); F_____; 10764 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0); 10765 10766 /*----------------------------------------------------------------------*/ 10767 /* PUSH/POP */ 10768 10769 } 10770 break; 10771 } 10772 break; 10773 case 0x39: 10774 GETBYTE (); 10775 switch (op[2] & 0x00) 10776 { 10777 case 0x00: 10778 goto op_semantics_89; 10779 break; 10780 } 10781 break; 10782 case 0x3a: 10783 GETBYTE (); 10784 switch (op[2] & 0x00) 10785 { 10786 case 0x00: 10787 goto op_semantics_89; 10788 break; 10789 } 10790 break; 10791 case 0x3c: 10792 GETBYTE (); 10793 switch (op[2] & 0x00) 10794 { 10795 case 0x00: 10796 goto op_semantics_89; 10797 break; 10798 } 10799 break; 10800 case 0x3d: 10801 GETBYTE (); 10802 switch (op[2] & 0x00) 10803 { 10804 case 0x00: 10805 goto op_semantics_89; 10806 break; 10807 } 10808 break; 10809 case 0x3e: 10810 GETBYTE (); 10811 switch (op[2] & 0x00) 10812 { 10813 case 0x00: 10814 goto op_semantics_89; 10815 break; 10816 } 10817 break; 10818 case 0x44: 10819 GETBYTE (); 10820 switch (op[2] & 0x00) 10821 { 10822 case 0x00: 10823 op_semantics_90: 10824 { 10825 /** 1111 1101 0100 a100 srca srcb msbhi %1, %2, %0 */ 10826 #line 1074 "rx-decode.opc" 10827 int a AU = (op[1] >> 3) & 0x01; 10828 #line 1074 "rx-decode.opc" 10829 int srca AU = (op[2] >> 4) & 0x0f; 10830 #line 1074 "rx-decode.opc" 10831 int srcb AU = op[2] & 0x0f; 10832 if (trace) 10833 { 10834 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10835 "/** 1111 1101 0100 a100 srca srcb msbhi %1, %2, %0 */", 10836 op[0], op[1], op[2]); 10837 printf (" a = 0x%x,", a); 10838 printf (" srca = 0x%x,", srca); 10839 printf (" srcb = 0x%x\n", srcb); 10840 } 10841 SYNTAX("msbhi %1, %2, %0"); 10842 #line 1074 "rx-decode.opc" 10843 ID(msbhi); DR(a+32); SR(srca); S2R(srcb); F_____; 10844 10845 } 10846 break; 10847 } 10848 break; 10849 case 0x45: 10850 GETBYTE (); 10851 switch (op[2] & 0x00) 10852 { 10853 case 0x00: 10854 op_semantics_91: 10855 { 10856 /** 1111 1101 0100 a101 srca srcb msblo %1, %2, %0 */ 10857 #line 1080 "rx-decode.opc" 10858 int a AU = (op[1] >> 3) & 0x01; 10859 #line 1080 "rx-decode.opc" 10860 int srca AU = (op[2] >> 4) & 0x0f; 10861 #line 1080 "rx-decode.opc" 10862 int srcb AU = op[2] & 0x0f; 10863 if (trace) 10864 { 10865 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10866 "/** 1111 1101 0100 a101 srca srcb msblo %1, %2, %0 */", 10867 op[0], op[1], op[2]); 10868 printf (" a = 0x%x,", a); 10869 printf (" srca = 0x%x,", srca); 10870 printf (" srcb = 0x%x\n", srcb); 10871 } 10872 SYNTAX("msblo %1, %2, %0"); 10873 #line 1080 "rx-decode.opc" 10874 ID(msblo); DR(a+32); SR(srca); S2R(srcb); F_____; 10875 10876 } 10877 break; 10878 } 10879 break; 10880 case 0x46: 10881 GETBYTE (); 10882 switch (op[2] & 0x00) 10883 { 10884 case 0x00: 10885 op_semantics_92: 10886 { 10887 /** 1111 1101 0100 a110 srca srcb msblh %1, %2, %0 */ 10888 #line 1077 "rx-decode.opc" 10889 int a AU = (op[1] >> 3) & 0x01; 10890 #line 1077 "rx-decode.opc" 10891 int srca AU = (op[2] >> 4) & 0x0f; 10892 #line 1077 "rx-decode.opc" 10893 int srcb AU = op[2] & 0x0f; 10894 if (trace) 10895 { 10896 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10897 "/** 1111 1101 0100 a110 srca srcb msblh %1, %2, %0 */", 10898 op[0], op[1], op[2]); 10899 printf (" a = 0x%x,", a); 10900 printf (" srca = 0x%x,", srca); 10901 printf (" srcb = 0x%x\n", srcb); 10902 } 10903 SYNTAX("msblh %1, %2, %0"); 10904 #line 1077 "rx-decode.opc" 10905 ID(msblh); DR(a+32); SR(srca); S2R(srcb); F_____; 10906 10907 } 10908 break; 10909 } 10910 break; 10911 case 0x47: 10912 GETBYTE (); 10913 switch (op[2] & 0x00) 10914 { 10915 case 0x00: 10916 op_semantics_93: 10917 { 10918 /** 1111 1101 0100 a111 srca srcb emsba %1, %2, %0 */ 10919 #line 1065 "rx-decode.opc" 10920 int a AU = (op[1] >> 3) & 0x01; 10921 #line 1065 "rx-decode.opc" 10922 int srca AU = (op[2] >> 4) & 0x0f; 10923 #line 1065 "rx-decode.opc" 10924 int srcb AU = op[2] & 0x0f; 10925 if (trace) 10926 { 10927 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10928 "/** 1111 1101 0100 a111 srca srcb emsba %1, %2, %0 */", 10929 op[0], op[1], op[2]); 10930 printf (" a = 0x%x,", a); 10931 printf (" srca = 0x%x,", srca); 10932 printf (" srcb = 0x%x\n", srcb); 10933 } 10934 SYNTAX("emsba %1, %2, %0"); 10935 #line 1065 "rx-decode.opc" 10936 ID(emsba); DR(a+32); SR(srca); S2R(srcb); F_____; 10937 10938 } 10939 break; 10940 } 10941 break; 10942 case 0x4c: 10943 GETBYTE (); 10944 switch (op[2] & 0x00) 10945 { 10946 case 0x00: 10947 goto op_semantics_90; 10948 break; 10949 } 10950 break; 10951 case 0x4d: 10952 GETBYTE (); 10953 switch (op[2] & 0x00) 10954 { 10955 case 0x00: 10956 goto op_semantics_91; 10957 break; 10958 } 10959 break; 10960 case 0x4e: 10961 GETBYTE (); 10962 switch (op[2] & 0x00) 10963 { 10964 case 0x00: 10965 goto op_semantics_92; 10966 break; 10967 } 10968 break; 10969 case 0x4f: 10970 GETBYTE (); 10971 switch (op[2] & 0x00) 10972 { 10973 case 0x00: 10974 goto op_semantics_93; 10975 break; 10976 } 10977 break; 10978 case 0x60: 10979 GETBYTE (); 10980 switch (op[2] & 0x00) 10981 { 10982 case 0x00: 10983 { 10984 /** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */ 10985 #line 733 "rx-decode.opc" 10986 int rsrc AU = (op[2] >> 4) & 0x0f; 10987 #line 733 "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 1101 0110 0000 rsrc rdst shlr %2, %0 */", 10993 op[0], op[1], op[2]); 10994 printf (" rsrc = 0x%x,", rsrc); 10995 printf (" rdst = 0x%x\n", rdst); 10996 } 10997 SYNTAX("shlr %2, %0"); 10998 #line 733 "rx-decode.opc" 10999 ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F__SZC; 11000 11001 } 11002 break; 11003 } 11004 break; 11005 case 0x61: 11006 GETBYTE (); 11007 switch (op[2] & 0x00) 11008 { 11009 case 0x00: 11010 { 11011 /** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */ 11012 #line 723 "rx-decode.opc" 11013 int rsrc AU = (op[2] >> 4) & 0x0f; 11014 #line 723 "rx-decode.opc" 11015 int rdst AU = op[2] & 0x0f; 11016 if (trace) 11017 { 11018 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11019 "/** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */", 11020 op[0], op[1], op[2]); 11021 printf (" rsrc = 0x%x,", rsrc); 11022 printf (" rdst = 0x%x\n", rdst); 11023 } 11024 SYNTAX("shar %2, %0"); 11025 #line 723 "rx-decode.opc" 11026 ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F_0SZC; 11027 11028 } 11029 break; 11030 } 11031 break; 11032 case 0x62: 11033 GETBYTE (); 11034 switch (op[2] & 0x00) 11035 { 11036 case 0x00: 11037 { 11038 /** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */ 11039 #line 713 "rx-decode.opc" 11040 int rsrc AU = (op[2] >> 4) & 0x0f; 11041 #line 713 "rx-decode.opc" 11042 int rdst AU = op[2] & 0x0f; 11043 if (trace) 11044 { 11045 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11046 "/** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */", 11047 op[0], op[1], op[2]); 11048 printf (" rsrc = 0x%x,", rsrc); 11049 printf (" rdst = 0x%x\n", rdst); 11050 } 11051 SYNTAX("shll %2, %0"); 11052 #line 713 "rx-decode.opc" 11053 ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F_OSZC; 11054 11055 } 11056 break; 11057 } 11058 break; 11059 case 0x64: 11060 GETBYTE (); 11061 switch (op[2] & 0x00) 11062 { 11063 case 0x00: 11064 { 11065 /** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */ 11066 #line 757 "rx-decode.opc" 11067 int rsrc AU = (op[2] >> 4) & 0x0f; 11068 #line 757 "rx-decode.opc" 11069 int rdst AU = op[2] & 0x0f; 11070 if (trace) 11071 { 11072 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11073 "/** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */", 11074 op[0], op[1], op[2]); 11075 printf (" rsrc = 0x%x,", rsrc); 11076 printf (" rdst = 0x%x\n", rdst); 11077 } 11078 SYNTAX("rotr %1, %0"); 11079 #line 757 "rx-decode.opc" 11080 ID(rotr); SR(rsrc); DR(rdst); F__SZC; 11081 11082 } 11083 break; 11084 } 11085 break; 11086 case 0x65: 11087 GETBYTE (); 11088 switch (op[2] & 0x00) 11089 { 11090 case 0x00: 11091 { 11092 /** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */ 11093 #line 760 "rx-decode.opc" 11094 int rsrc AU = (op[2] >> 4) & 0x0f; 11095 #line 760 "rx-decode.opc" 11096 int rdst AU = op[2] & 0x0f; 11097 if (trace) 11098 { 11099 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11100 "/** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */", 11101 op[0], op[1], op[2]); 11102 printf (" rsrc = 0x%x,", rsrc); 11103 printf (" rdst = 0x%x\n", rdst); 11104 } 11105 SYNTAX("revw %1, %0"); 11106 #line 760 "rx-decode.opc" 11107 ID(revw); SR(rsrc); DR(rdst); 11108 11109 } 11110 break; 11111 } 11112 break; 11113 case 0x66: 11114 GETBYTE (); 11115 switch (op[2] & 0x00) 11116 { 11117 case 0x00: 11118 { 11119 /** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */ 11120 #line 751 "rx-decode.opc" 11121 int rsrc AU = (op[2] >> 4) & 0x0f; 11122 #line 751 "rx-decode.opc" 11123 int rdst AU = op[2] & 0x0f; 11124 if (trace) 11125 { 11126 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11127 "/** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */", 11128 op[0], op[1], op[2]); 11129 printf (" rsrc = 0x%x,", rsrc); 11130 printf (" rdst = 0x%x\n", rdst); 11131 } 11132 SYNTAX("rotl %1, %0"); 11133 #line 751 "rx-decode.opc" 11134 ID(rotl); SR(rsrc); DR(rdst); F__SZC; 11135 11136 } 11137 break; 11138 } 11139 break; 11140 case 0x67: 11141 GETBYTE (); 11142 switch (op[2] & 0x00) 11143 { 11144 case 0x00: 11145 { 11146 /** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */ 11147 #line 763 "rx-decode.opc" 11148 int rsrc AU = (op[2] >> 4) & 0x0f; 11149 #line 763 "rx-decode.opc" 11150 int rdst AU = op[2] & 0x0f; 11151 if (trace) 11152 { 11153 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11154 "/** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */", 11155 op[0], op[1], op[2]); 11156 printf (" rsrc = 0x%x,", rsrc); 11157 printf (" rdst = 0x%x\n", rdst); 11158 } 11159 SYNTAX("revl %1, %0"); 11160 #line 763 "rx-decode.opc" 11161 ID(revl); SR(rsrc); DR(rdst); 11162 11163 /*----------------------------------------------------------------------*/ 11164 /* BRANCH */ 11165 11166 } 11167 break; 11168 } 11169 break; 11170 case 0x68: 11171 GETBYTE (); 11172 switch (op[2] & 0x00) 11173 { 11174 case 0x00: 11175 op_semantics_94: 11176 { 11177 /** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */ 11178 #line 1014 "rx-decode.opc" 11179 int c AU = op[1] & 0x01; 11180 #line 1014 "rx-decode.opc" 11181 int rsrc AU = (op[2] >> 4) & 0x0f; 11182 #line 1014 "rx-decode.opc" 11183 int rdst AU = op[2] & 0x0f; 11184 if (trace) 11185 { 11186 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11187 "/** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */", 11188 op[0], op[1], op[2]); 11189 printf (" c = 0x%x,", c); 11190 printf (" rsrc = 0x%x,", rsrc); 11191 printf (" rdst = 0x%x\n", rdst); 11192 } 11193 SYNTAX("mvtc %1, %0"); 11194 #line 1014 "rx-decode.opc" 11195 ID(mov); SR(rsrc); DR(c*16+rdst + 16); 11196 11197 } 11198 break; 11199 } 11200 break; 11201 case 0x69: 11202 GETBYTE (); 11203 switch (op[2] & 0x00) 11204 { 11205 case 0x00: 11206 goto op_semantics_94; 11207 break; 11208 } 11209 break; 11210 case 0x6a: 11211 GETBYTE (); 11212 switch (op[2] & 0x00) 11213 { 11214 case 0x00: 11215 op_semantics_95: 11216 { 11217 /** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */ 11218 #line 1017 "rx-decode.opc" 11219 int s AU = op[1] & 0x01; 11220 #line 1017 "rx-decode.opc" 11221 int rsrc AU = (op[2] >> 4) & 0x0f; 11222 #line 1017 "rx-decode.opc" 11223 int rdst AU = op[2] & 0x0f; 11224 if (trace) 11225 { 11226 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11227 "/** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */", 11228 op[0], op[1], op[2]); 11229 printf (" s = 0x%x,", s); 11230 printf (" rsrc = 0x%x,", rsrc); 11231 printf (" rdst = 0x%x\n", rdst); 11232 } 11233 SYNTAX("mvfc %1, %0"); 11234 #line 1017 "rx-decode.opc" 11235 ID(mov); SR((s*16+rsrc) + 16); DR(rdst); 11236 11237 /*----------------------------------------------------------------------*/ 11238 /* INTERRUPTS */ 11239 11240 } 11241 break; 11242 } 11243 break; 11244 case 0x6b: 11245 GETBYTE (); 11246 switch (op[2] & 0x00) 11247 { 11248 case 0x00: 11249 goto op_semantics_95; 11250 break; 11251 } 11252 break; 11253 case 0x6c: 11254 GETBYTE (); 11255 switch (op[2] & 0x00) 11256 { 11257 case 0x00: 11258 op_semantics_96: 11259 { 11260 /** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */ 11261 #line 754 "rx-decode.opc" 11262 int i AU = op[1] & 0x01; 11263 #line 754 "rx-decode.opc" 11264 int mmmm AU = (op[2] >> 4) & 0x0f; 11265 #line 754 "rx-decode.opc" 11266 int rdst AU = op[2] & 0x0f; 11267 if (trace) 11268 { 11269 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11270 "/** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */", 11271 op[0], op[1], op[2]); 11272 printf (" i = 0x%x,", i); 11273 printf (" mmmm = 0x%x,", mmmm); 11274 printf (" rdst = 0x%x\n", rdst); 11275 } 11276 SYNTAX("rotr #%1, %0"); 11277 #line 754 "rx-decode.opc" 11278 ID(rotr); SC(i*16+mmmm); DR(rdst); F__SZC; 11279 11280 } 11281 break; 11282 } 11283 break; 11284 case 0x6d: 11285 GETBYTE (); 11286 switch (op[2] & 0x00) 11287 { 11288 case 0x00: 11289 goto op_semantics_96; 11290 break; 11291 } 11292 break; 11293 case 0x6e: 11294 GETBYTE (); 11295 switch (op[2] & 0x00) 11296 { 11297 case 0x00: 11298 op_semantics_97: 11299 { 11300 /** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */ 11301 #line 748 "rx-decode.opc" 11302 int i AU = op[1] & 0x01; 11303 #line 748 "rx-decode.opc" 11304 int mmmm AU = (op[2] >> 4) & 0x0f; 11305 #line 748 "rx-decode.opc" 11306 int rdst AU = op[2] & 0x0f; 11307 if (trace) 11308 { 11309 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11310 "/** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */", 11311 op[0], op[1], op[2]); 11312 printf (" i = 0x%x,", i); 11313 printf (" mmmm = 0x%x,", mmmm); 11314 printf (" rdst = 0x%x\n", rdst); 11315 } 11316 SYNTAX("rotl #%1, %0"); 11317 #line 748 "rx-decode.opc" 11318 ID(rotl); SC(i*16+mmmm); DR(rdst); F__SZC; 11319 11320 } 11321 break; 11322 } 11323 break; 11324 case 0x6f: 11325 GETBYTE (); 11326 switch (op[2] & 0x00) 11327 { 11328 case 0x00: 11329 goto op_semantics_97; 11330 break; 11331 } 11332 break; 11333 case 0x70: 11334 GETBYTE (); 11335 switch (op[2] & 0xf0) 11336 { 11337 case 0x20: 11338 op_semantics_98: 11339 { 11340 /** 1111 1101 0111 im00 0010rdst adc #%1, %0 */ 11341 #line 492 "rx-decode.opc" 11342 int im AU = (op[1] >> 2) & 0x03; 11343 #line 492 "rx-decode.opc" 11344 int rdst AU = op[2] & 0x0f; 11345 if (trace) 11346 { 11347 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11348 "/** 1111 1101 0111 im00 0010rdst adc #%1, %0 */", 11349 op[0], op[1], op[2]); 11350 printf (" im = 0x%x,", im); 11351 printf (" rdst = 0x%x\n", rdst); 11352 } 11353 SYNTAX("adc #%1, %0"); 11354 #line 492 "rx-decode.opc" 11355 ID(adc); SC(IMMex(im)); DR(rdst); F_OSZC; 11356 11357 } 11358 break; 11359 case 0x40: 11360 op_semantics_99: 11361 { 11362 /** 1111 1101 0111 im00 0100rdst max #%1, %0 */ 11363 #line 574 "rx-decode.opc" 11364 int im AU = (op[1] >> 2) & 0x03; 11365 #line 574 "rx-decode.opc" 11366 int rdst AU = op[2] & 0x0f; 11367 if (trace) 11368 { 11369 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11370 "/** 1111 1101 0111 im00 0100rdst max #%1, %0 */", 11371 op[0], op[1], op[2]); 11372 printf (" im = 0x%x,", im); 11373 printf (" rdst = 0x%x\n", rdst); 11374 } 11375 SYNTAX("max #%1, %0"); 11376 #line 574 "rx-decode.opc" 11377 int val = IMMex (im); 11378 if (im == 0 && (unsigned) val == 0x80000000 && rdst == 0) 11379 { 11380 ID (nop7); 11381 SYNTAX("nop\t; max\t#0x80000000, r0"); 11382 } 11383 else 11384 { 11385 ID(max); 11386 } 11387 DR(rdst); SC(val); 11388 11389 } 11390 break; 11391 case 0x50: 11392 op_semantics_100: 11393 { 11394 /** 1111 1101 0111 im00 0101rdst min #%1, %0 */ 11395 #line 604 "rx-decode.opc" 11396 int im AU = (op[1] >> 2) & 0x03; 11397 #line 604 "rx-decode.opc" 11398 int rdst AU = op[2] & 0x0f; 11399 if (trace) 11400 { 11401 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11402 "/** 1111 1101 0111 im00 0101rdst min #%1, %0 */", 11403 op[0], op[1], op[2]); 11404 printf (" im = 0x%x,", im); 11405 printf (" rdst = 0x%x\n", rdst); 11406 } 11407 SYNTAX("min #%1, %0"); 11408 #line 604 "rx-decode.opc" 11409 ID(min); DR(rdst); SC(IMMex(im)); 11410 11411 } 11412 break; 11413 case 0x60: 11414 op_semantics_101: 11415 { 11416 /** 1111 1101 0111 im00 0110rdst emul #%1, %0 */ 11417 #line 662 "rx-decode.opc" 11418 int im AU = (op[1] >> 2) & 0x03; 11419 #line 662 "rx-decode.opc" 11420 int rdst AU = op[2] & 0x0f; 11421 if (trace) 11422 { 11423 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11424 "/** 1111 1101 0111 im00 0110rdst emul #%1, %0 */", 11425 op[0], op[1], op[2]); 11426 printf (" im = 0x%x,", im); 11427 printf (" rdst = 0x%x\n", rdst); 11428 } 11429 SYNTAX("emul #%1, %0"); 11430 #line 662 "rx-decode.opc" 11431 ID(emul); DR(rdst); SC(IMMex(im)); 11432 11433 } 11434 break; 11435 case 0x70: 11436 op_semantics_102: 11437 { 11438 /** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */ 11439 #line 674 "rx-decode.opc" 11440 int im AU = (op[1] >> 2) & 0x03; 11441 #line 674 "rx-decode.opc" 11442 int rdst AU = op[2] & 0x0f; 11443 if (trace) 11444 { 11445 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11446 "/** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */", 11447 op[0], op[1], op[2]); 11448 printf (" im = 0x%x,", im); 11449 printf (" rdst = 0x%x\n", rdst); 11450 } 11451 SYNTAX("emulu #%1, %0"); 11452 #line 674 "rx-decode.opc" 11453 ID(emulu); DR(rdst); SC(IMMex(im)); 11454 11455 } 11456 break; 11457 case 0x80: 11458 op_semantics_103: 11459 { 11460 /** 1111 1101 0111 im00 1000rdst div #%1, %0 */ 11461 #line 686 "rx-decode.opc" 11462 int im AU = (op[1] >> 2) & 0x03; 11463 #line 686 "rx-decode.opc" 11464 int rdst AU = op[2] & 0x0f; 11465 if (trace) 11466 { 11467 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11468 "/** 1111 1101 0111 im00 1000rdst div #%1, %0 */", 11469 op[0], op[1], op[2]); 11470 printf (" im = 0x%x,", im); 11471 printf (" rdst = 0x%x\n", rdst); 11472 } 11473 SYNTAX("div #%1, %0"); 11474 #line 686 "rx-decode.opc" 11475 ID(div); DR(rdst); SC(IMMex(im)); F_O___; 11476 11477 } 11478 break; 11479 case 0x90: 11480 op_semantics_104: 11481 { 11482 /** 1111 1101 0111 im00 1001rdst divu #%1, %0 */ 11483 #line 698 "rx-decode.opc" 11484 int im AU = (op[1] >> 2) & 0x03; 11485 #line 698 "rx-decode.opc" 11486 int rdst AU = op[2] & 0x0f; 11487 if (trace) 11488 { 11489 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11490 "/** 1111 1101 0111 im00 1001rdst divu #%1, %0 */", 11491 op[0], op[1], op[2]); 11492 printf (" im = 0x%x,", im); 11493 printf (" rdst = 0x%x\n", rdst); 11494 } 11495 SYNTAX("divu #%1, %0"); 11496 #line 698 "rx-decode.opc" 11497 ID(divu); DR(rdst); SC(IMMex(im)); F_O___; 11498 11499 } 11500 break; 11501 case 0xc0: 11502 op_semantics_105: 11503 { 11504 /** 1111 1101 0111 im00 1100rdst tst #%1, %2 */ 11505 #line 471 "rx-decode.opc" 11506 int im AU = (op[1] >> 2) & 0x03; 11507 #line 471 "rx-decode.opc" 11508 int rdst AU = op[2] & 0x0f; 11509 if (trace) 11510 { 11511 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11512 "/** 1111 1101 0111 im00 1100rdst tst #%1, %2 */", 11513 op[0], op[1], op[2]); 11514 printf (" im = 0x%x,", im); 11515 printf (" rdst = 0x%x\n", rdst); 11516 } 11517 SYNTAX("tst #%1, %2"); 11518 #line 471 "rx-decode.opc" 11519 ID(and); SC(IMMex(im)); S2R(rdst); F__SZ_; 11520 11521 } 11522 break; 11523 case 0xd0: 11524 op_semantics_106: 11525 { 11526 /** 1111 1101 0111 im00 1101rdst xor #%1, %0 */ 11527 #line 450 "rx-decode.opc" 11528 int im AU = (op[1] >> 2) & 0x03; 11529 #line 450 "rx-decode.opc" 11530 int rdst AU = op[2] & 0x0f; 11531 if (trace) 11532 { 11533 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11534 "/** 1111 1101 0111 im00 1101rdst xor #%1, %0 */", 11535 op[0], op[1], op[2]); 11536 printf (" im = 0x%x,", im); 11537 printf (" rdst = 0x%x\n", rdst); 11538 } 11539 SYNTAX("xor #%1, %0"); 11540 #line 450 "rx-decode.opc" 11541 ID(xor); SC(IMMex(im)); DR(rdst); F__SZ_; 11542 11543 } 11544 break; 11545 case 0xe0: 11546 op_semantics_107: 11547 { 11548 /** 1111 1101 0111 im00 1110rdst stz #%1, %0 */ 11549 #line 396 "rx-decode.opc" 11550 int im AU = (op[1] >> 2) & 0x03; 11551 #line 396 "rx-decode.opc" 11552 int rdst AU = op[2] & 0x0f; 11553 if (trace) 11554 { 11555 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11556 "/** 1111 1101 0111 im00 1110rdst stz #%1, %0 */", 11557 op[0], op[1], op[2]); 11558 printf (" im = 0x%x,", im); 11559 printf (" rdst = 0x%x\n", rdst); 11560 } 11561 SYNTAX("stz #%1, %0"); 11562 #line 396 "rx-decode.opc" 11563 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z); 11564 11565 } 11566 break; 11567 case 0xf0: 11568 op_semantics_108: 11569 { 11570 /** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */ 11571 #line 399 "rx-decode.opc" 11572 int im AU = (op[1] >> 2) & 0x03; 11573 #line 399 "rx-decode.opc" 11574 int rdst AU = op[2] & 0x0f; 11575 if (trace) 11576 { 11577 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11578 "/** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */", 11579 op[0], op[1], op[2]); 11580 printf (" im = 0x%x,", im); 11581 printf (" rdst = 0x%x\n", rdst); 11582 } 11583 SYNTAX("stnz #%1, %0"); 11584 #line 399 "rx-decode.opc" 11585 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz); 11586 11587 /*----------------------------------------------------------------------*/ 11588 /* RTSD */ 11589 11590 } 11591 break; 11592 default: UNSUPPORTED(); break; 11593 } 11594 break; 11595 case 0x72: 11596 GETBYTE (); 11597 switch (op[2] & 0xf0) 11598 { 11599 case 0x00: 11600 { 11601 /** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */ 11602 #line 906 "rx-decode.opc" 11603 int rdst AU = op[2] & 0x0f; 11604 if (trace) 11605 { 11606 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11607 "/** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */", 11608 op[0], op[1], op[2]); 11609 printf (" rdst = 0x%x\n", rdst); 11610 } 11611 SYNTAX("fsub #%1, %0"); 11612 #line 906 "rx-decode.opc" 11613 ID(fsub); DR(rdst); SC(IMM(0)); F__SZ_; 11614 11615 } 11616 break; 11617 case 0x10: 11618 { 11619 /** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */ 11620 #line 900 "rx-decode.opc" 11621 int rdst AU = op[2] & 0x0f; 11622 if (trace) 11623 { 11624 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11625 "/** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */", 11626 op[0], op[1], op[2]); 11627 printf (" rdst = 0x%x\n", rdst); 11628 } 11629 SYNTAX("fcmp #%1, %0"); 11630 #line 900 "rx-decode.opc" 11631 ID(fcmp); DR(rdst); SC(IMM(0)); F_OSZ_; 11632 11633 } 11634 break; 11635 case 0x20: 11636 { 11637 /** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */ 11638 #line 894 "rx-decode.opc" 11639 int rdst AU = op[2] & 0x0f; 11640 if (trace) 11641 { 11642 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11643 "/** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */", 11644 op[0], op[1], op[2]); 11645 printf (" rdst = 0x%x\n", rdst); 11646 } 11647 SYNTAX("fadd #%1, %0"); 11648 #line 894 "rx-decode.opc" 11649 ID(fadd); DR(rdst); SC(IMM(0)); F__SZ_; 11650 11651 } 11652 break; 11653 case 0x30: 11654 { 11655 /** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */ 11656 #line 915 "rx-decode.opc" 11657 int rdst AU = op[2] & 0x0f; 11658 if (trace) 11659 { 11660 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11661 "/** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */", 11662 op[0], op[1], op[2]); 11663 printf (" rdst = 0x%x\n", rdst); 11664 } 11665 SYNTAX("fmul #%1, %0"); 11666 #line 915 "rx-decode.opc" 11667 ID(fmul); DR(rdst); SC(IMM(0)); F__SZ_; 11668 11669 } 11670 break; 11671 case 0x40: 11672 { 11673 /** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */ 11674 #line 921 "rx-decode.opc" 11675 int rdst AU = op[2] & 0x0f; 11676 if (trace) 11677 { 11678 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11679 "/** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */", 11680 op[0], op[1], op[2]); 11681 printf (" rdst = 0x%x\n", rdst); 11682 } 11683 SYNTAX("fdiv #%1, %0"); 11684 #line 921 "rx-decode.opc" 11685 ID(fdiv); DR(rdst); SC(IMM(0)); F__SZ_; 11686 11687 } 11688 break; 11689 default: UNSUPPORTED(); break; 11690 } 11691 break; 11692 case 0x73: 11693 GETBYTE (); 11694 switch (op[2] & 0xe0) 11695 { 11696 case 0x00: 11697 op_semantics_109: 11698 { 11699 /** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */ 11700 #line 1011 "rx-decode.opc" 11701 int im AU = (op[1] >> 2) & 0x03; 11702 #line 1011 "rx-decode.opc" 11703 int crdst AU = op[2] & 0x1f; 11704 if (trace) 11705 { 11706 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11707 "/** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */", 11708 op[0], op[1], op[2]); 11709 printf (" im = 0x%x,", im); 11710 printf (" crdst = 0x%x\n", crdst); 11711 } 11712 SYNTAX("mvtc #%1, %0"); 11713 #line 1011 "rx-decode.opc" 11714 ID(mov); SC(IMMex(im)); DR(crdst + 16); 11715 11716 } 11717 break; 11718 default: UNSUPPORTED(); break; 11719 } 11720 break; 11721 case 0x74: 11722 GETBYTE (); 11723 switch (op[2] & 0xf0) 11724 { 11725 case 0x20: 11726 goto op_semantics_98; 11727 break; 11728 case 0x40: 11729 goto op_semantics_99; 11730 break; 11731 case 0x50: 11732 goto op_semantics_100; 11733 break; 11734 case 0x60: 11735 goto op_semantics_101; 11736 break; 11737 case 0x70: 11738 goto op_semantics_102; 11739 break; 11740 case 0x80: 11741 goto op_semantics_103; 11742 break; 11743 case 0x90: 11744 goto op_semantics_104; 11745 break; 11746 case 0xc0: 11747 goto op_semantics_105; 11748 break; 11749 case 0xd0: 11750 goto op_semantics_106; 11751 break; 11752 case 0xe0: 11753 goto op_semantics_107; 11754 break; 11755 case 0xf0: 11756 goto op_semantics_108; 11757 break; 11758 default: UNSUPPORTED(); break; 11759 } 11760 break; 11761 case 0x77: 11762 GETBYTE (); 11763 switch (op[2] & 0xe0) 11764 { 11765 case 0x00: 11766 goto op_semantics_109; 11767 break; 11768 default: UNSUPPORTED(); break; 11769 } 11770 break; 11771 case 0x78: 11772 GETBYTE (); 11773 switch (op[2] & 0xf0) 11774 { 11775 case 0x20: 11776 goto op_semantics_98; 11777 break; 11778 case 0x40: 11779 goto op_semantics_99; 11780 break; 11781 case 0x50: 11782 goto op_semantics_100; 11783 break; 11784 case 0x60: 11785 goto op_semantics_101; 11786 break; 11787 case 0x70: 11788 goto op_semantics_102; 11789 break; 11790 case 0x80: 11791 goto op_semantics_103; 11792 break; 11793 case 0x90: 11794 goto op_semantics_104; 11795 break; 11796 case 0xc0: 11797 goto op_semantics_105; 11798 break; 11799 case 0xd0: 11800 goto op_semantics_106; 11801 break; 11802 case 0xe0: 11803 goto op_semantics_107; 11804 break; 11805 case 0xf0: 11806 goto op_semantics_108; 11807 break; 11808 default: UNSUPPORTED(); break; 11809 } 11810 break; 11811 case 0x7b: 11812 GETBYTE (); 11813 switch (op[2] & 0xe0) 11814 { 11815 case 0x00: 11816 goto op_semantics_109; 11817 break; 11818 default: UNSUPPORTED(); break; 11819 } 11820 break; 11821 case 0x7c: 11822 GETBYTE (); 11823 switch (op[2] & 0xf0) 11824 { 11825 case 0x20: 11826 goto op_semantics_98; 11827 break; 11828 case 0x40: 11829 goto op_semantics_99; 11830 break; 11831 case 0x50: 11832 goto op_semantics_100; 11833 break; 11834 case 0x60: 11835 goto op_semantics_101; 11836 break; 11837 case 0x70: 11838 goto op_semantics_102; 11839 break; 11840 case 0x80: 11841 goto op_semantics_103; 11842 break; 11843 case 0x90: 11844 goto op_semantics_104; 11845 break; 11846 case 0xc0: 11847 goto op_semantics_105; 11848 break; 11849 case 0xd0: 11850 goto op_semantics_106; 11851 break; 11852 case 0xe0: 11853 goto op_semantics_107; 11854 break; 11855 case 0xf0: 11856 goto op_semantics_108; 11857 break; 11858 default: UNSUPPORTED(); break; 11859 } 11860 break; 11861 case 0x7f: 11862 GETBYTE (); 11863 switch (op[2] & 0xe0) 11864 { 11865 case 0x00: 11866 goto op_semantics_109; 11867 break; 11868 default: UNSUPPORTED(); break; 11869 } 11870 break; 11871 case 0x80: 11872 GETBYTE (); 11873 switch (op[2] & 0x00) 11874 { 11875 case 0x00: 11876 op_semantics_110: 11877 { 11878 /** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */ 11879 #line 736 "rx-decode.opc" 11880 int immmm AU = op[1] & 0x1f; 11881 #line 736 "rx-decode.opc" 11882 int rsrc AU = (op[2] >> 4) & 0x0f; 11883 #line 736 "rx-decode.opc" 11884 int rdst AU = op[2] & 0x0f; 11885 if (trace) 11886 { 11887 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11888 "/** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */", 11889 op[0], op[1], op[2]); 11890 printf (" immmm = 0x%x,", immmm); 11891 printf (" rsrc = 0x%x,", rsrc); 11892 printf (" rdst = 0x%x\n", rdst); 11893 } 11894 SYNTAX("shlr #%2, %1, %0"); 11895 #line 736 "rx-decode.opc" 11896 ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F__SZC; 11897 11898 /*----------------------------------------------------------------------*/ 11899 /* ROTATE */ 11900 11901 } 11902 break; 11903 } 11904 break; 11905 case 0x81: 11906 GETBYTE (); 11907 switch (op[2] & 0x00) 11908 { 11909 case 0x00: 11910 goto op_semantics_110; 11911 break; 11912 } 11913 break; 11914 case 0x82: 11915 GETBYTE (); 11916 switch (op[2] & 0x00) 11917 { 11918 case 0x00: 11919 goto op_semantics_110; 11920 break; 11921 } 11922 break; 11923 case 0x83: 11924 GETBYTE (); 11925 switch (op[2] & 0x00) 11926 { 11927 case 0x00: 11928 goto op_semantics_110; 11929 break; 11930 } 11931 break; 11932 case 0x84: 11933 GETBYTE (); 11934 switch (op[2] & 0x00) 11935 { 11936 case 0x00: 11937 goto op_semantics_110; 11938 break; 11939 } 11940 break; 11941 case 0x85: 11942 GETBYTE (); 11943 switch (op[2] & 0x00) 11944 { 11945 case 0x00: 11946 goto op_semantics_110; 11947 break; 11948 } 11949 break; 11950 case 0x86: 11951 GETBYTE (); 11952 switch (op[2] & 0x00) 11953 { 11954 case 0x00: 11955 goto op_semantics_110; 11956 break; 11957 } 11958 break; 11959 case 0x87: 11960 GETBYTE (); 11961 switch (op[2] & 0x00) 11962 { 11963 case 0x00: 11964 goto op_semantics_110; 11965 break; 11966 } 11967 break; 11968 case 0x88: 11969 GETBYTE (); 11970 switch (op[2] & 0x00) 11971 { 11972 case 0x00: 11973 goto op_semantics_110; 11974 break; 11975 } 11976 break; 11977 case 0x89: 11978 GETBYTE (); 11979 switch (op[2] & 0x00) 11980 { 11981 case 0x00: 11982 goto op_semantics_110; 11983 break; 11984 } 11985 break; 11986 case 0x8a: 11987 GETBYTE (); 11988 switch (op[2] & 0x00) 11989 { 11990 case 0x00: 11991 goto op_semantics_110; 11992 break; 11993 } 11994 break; 11995 case 0x8b: 11996 GETBYTE (); 11997 switch (op[2] & 0x00) 11998 { 11999 case 0x00: 12000 goto op_semantics_110; 12001 break; 12002 } 12003 break; 12004 case 0x8c: 12005 GETBYTE (); 12006 switch (op[2] & 0x00) 12007 { 12008 case 0x00: 12009 goto op_semantics_110; 12010 break; 12011 } 12012 break; 12013 case 0x8d: 12014 GETBYTE (); 12015 switch (op[2] & 0x00) 12016 { 12017 case 0x00: 12018 goto op_semantics_110; 12019 break; 12020 } 12021 break; 12022 case 0x8e: 12023 GETBYTE (); 12024 switch (op[2] & 0x00) 12025 { 12026 case 0x00: 12027 goto op_semantics_110; 12028 break; 12029 } 12030 break; 12031 case 0x8f: 12032 GETBYTE (); 12033 switch (op[2] & 0x00) 12034 { 12035 case 0x00: 12036 goto op_semantics_110; 12037 break; 12038 } 12039 break; 12040 case 0x90: 12041 GETBYTE (); 12042 switch (op[2] & 0x00) 12043 { 12044 case 0x00: 12045 goto op_semantics_110; 12046 break; 12047 } 12048 break; 12049 case 0x91: 12050 GETBYTE (); 12051 switch (op[2] & 0x00) 12052 { 12053 case 0x00: 12054 goto op_semantics_110; 12055 break; 12056 } 12057 break; 12058 case 0x92: 12059 GETBYTE (); 12060 switch (op[2] & 0x00) 12061 { 12062 case 0x00: 12063 goto op_semantics_110; 12064 break; 12065 } 12066 break; 12067 case 0x93: 12068 GETBYTE (); 12069 switch (op[2] & 0x00) 12070 { 12071 case 0x00: 12072 goto op_semantics_110; 12073 break; 12074 } 12075 break; 12076 case 0x94: 12077 GETBYTE (); 12078 switch (op[2] & 0x00) 12079 { 12080 case 0x00: 12081 goto op_semantics_110; 12082 break; 12083 } 12084 break; 12085 case 0x95: 12086 GETBYTE (); 12087 switch (op[2] & 0x00) 12088 { 12089 case 0x00: 12090 goto op_semantics_110; 12091 break; 12092 } 12093 break; 12094 case 0x96: 12095 GETBYTE (); 12096 switch (op[2] & 0x00) 12097 { 12098 case 0x00: 12099 goto op_semantics_110; 12100 break; 12101 } 12102 break; 12103 case 0x97: 12104 GETBYTE (); 12105 switch (op[2] & 0x00) 12106 { 12107 case 0x00: 12108 goto op_semantics_110; 12109 break; 12110 } 12111 break; 12112 case 0x98: 12113 GETBYTE (); 12114 switch (op[2] & 0x00) 12115 { 12116 case 0x00: 12117 goto op_semantics_110; 12118 break; 12119 } 12120 break; 12121 case 0x99: 12122 GETBYTE (); 12123 switch (op[2] & 0x00) 12124 { 12125 case 0x00: 12126 goto op_semantics_110; 12127 break; 12128 } 12129 break; 12130 case 0x9a: 12131 GETBYTE (); 12132 switch (op[2] & 0x00) 12133 { 12134 case 0x00: 12135 goto op_semantics_110; 12136 break; 12137 } 12138 break; 12139 case 0x9b: 12140 GETBYTE (); 12141 switch (op[2] & 0x00) 12142 { 12143 case 0x00: 12144 goto op_semantics_110; 12145 break; 12146 } 12147 break; 12148 case 0x9c: 12149 GETBYTE (); 12150 switch (op[2] & 0x00) 12151 { 12152 case 0x00: 12153 goto op_semantics_110; 12154 break; 12155 } 12156 break; 12157 case 0x9d: 12158 GETBYTE (); 12159 switch (op[2] & 0x00) 12160 { 12161 case 0x00: 12162 goto op_semantics_110; 12163 break; 12164 } 12165 break; 12166 case 0x9e: 12167 GETBYTE (); 12168 switch (op[2] & 0x00) 12169 { 12170 case 0x00: 12171 goto op_semantics_110; 12172 break; 12173 } 12174 break; 12175 case 0x9f: 12176 GETBYTE (); 12177 switch (op[2] & 0x00) 12178 { 12179 case 0x00: 12180 goto op_semantics_110; 12181 break; 12182 } 12183 break; 12184 case 0xa0: 12185 GETBYTE (); 12186 switch (op[2] & 0x00) 12187 { 12188 case 0x00: 12189 op_semantics_111: 12190 { 12191 /** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */ 12192 #line 726 "rx-decode.opc" 12193 int immmm AU = op[1] & 0x1f; 12194 #line 726 "rx-decode.opc" 12195 int rsrc AU = (op[2] >> 4) & 0x0f; 12196 #line 726 "rx-decode.opc" 12197 int rdst AU = op[2] & 0x0f; 12198 if (trace) 12199 { 12200 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12201 "/** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */", 12202 op[0], op[1], op[2]); 12203 printf (" immmm = 0x%x,", immmm); 12204 printf (" rsrc = 0x%x,", rsrc); 12205 printf (" rdst = 0x%x\n", rdst); 12206 } 12207 SYNTAX("shar #%2, %1, %0"); 12208 #line 726 "rx-decode.opc" 12209 ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F_0SZC; 12210 12211 12212 } 12213 break; 12214 } 12215 break; 12216 case 0xa1: 12217 GETBYTE (); 12218 switch (op[2] & 0x00) 12219 { 12220 case 0x00: 12221 goto op_semantics_111; 12222 break; 12223 } 12224 break; 12225 case 0xa2: 12226 GETBYTE (); 12227 switch (op[2] & 0x00) 12228 { 12229 case 0x00: 12230 goto op_semantics_111; 12231 break; 12232 } 12233 break; 12234 case 0xa3: 12235 GETBYTE (); 12236 switch (op[2] & 0x00) 12237 { 12238 case 0x00: 12239 goto op_semantics_111; 12240 break; 12241 } 12242 break; 12243 case 0xa4: 12244 GETBYTE (); 12245 switch (op[2] & 0x00) 12246 { 12247 case 0x00: 12248 goto op_semantics_111; 12249 break; 12250 } 12251 break; 12252 case 0xa5: 12253 GETBYTE (); 12254 switch (op[2] & 0x00) 12255 { 12256 case 0x00: 12257 goto op_semantics_111; 12258 break; 12259 } 12260 break; 12261 case 0xa6: 12262 GETBYTE (); 12263 switch (op[2] & 0x00) 12264 { 12265 case 0x00: 12266 goto op_semantics_111; 12267 break; 12268 } 12269 break; 12270 case 0xa7: 12271 GETBYTE (); 12272 switch (op[2] & 0x00) 12273 { 12274 case 0x00: 12275 goto op_semantics_111; 12276 break; 12277 } 12278 break; 12279 case 0xa8: 12280 GETBYTE (); 12281 switch (op[2] & 0x00) 12282 { 12283 case 0x00: 12284 goto op_semantics_111; 12285 break; 12286 } 12287 break; 12288 case 0xa9: 12289 GETBYTE (); 12290 switch (op[2] & 0x00) 12291 { 12292 case 0x00: 12293 goto op_semantics_111; 12294 break; 12295 } 12296 break; 12297 case 0xaa: 12298 GETBYTE (); 12299 switch (op[2] & 0x00) 12300 { 12301 case 0x00: 12302 goto op_semantics_111; 12303 break; 12304 } 12305 break; 12306 case 0xab: 12307 GETBYTE (); 12308 switch (op[2] & 0x00) 12309 { 12310 case 0x00: 12311 goto op_semantics_111; 12312 break; 12313 } 12314 break; 12315 case 0xac: 12316 GETBYTE (); 12317 switch (op[2] & 0x00) 12318 { 12319 case 0x00: 12320 goto op_semantics_111; 12321 break; 12322 } 12323 break; 12324 case 0xad: 12325 GETBYTE (); 12326 switch (op[2] & 0x00) 12327 { 12328 case 0x00: 12329 goto op_semantics_111; 12330 break; 12331 } 12332 break; 12333 case 0xae: 12334 GETBYTE (); 12335 switch (op[2] & 0x00) 12336 { 12337 case 0x00: 12338 goto op_semantics_111; 12339 break; 12340 } 12341 break; 12342 case 0xaf: 12343 GETBYTE (); 12344 switch (op[2] & 0x00) 12345 { 12346 case 0x00: 12347 goto op_semantics_111; 12348 break; 12349 } 12350 break; 12351 case 0xb0: 12352 GETBYTE (); 12353 switch (op[2] & 0x00) 12354 { 12355 case 0x00: 12356 goto op_semantics_111; 12357 break; 12358 } 12359 break; 12360 case 0xb1: 12361 GETBYTE (); 12362 switch (op[2] & 0x00) 12363 { 12364 case 0x00: 12365 goto op_semantics_111; 12366 break; 12367 } 12368 break; 12369 case 0xb2: 12370 GETBYTE (); 12371 switch (op[2] & 0x00) 12372 { 12373 case 0x00: 12374 goto op_semantics_111; 12375 break; 12376 } 12377 break; 12378 case 0xb3: 12379 GETBYTE (); 12380 switch (op[2] & 0x00) 12381 { 12382 case 0x00: 12383 goto op_semantics_111; 12384 break; 12385 } 12386 break; 12387 case 0xb4: 12388 GETBYTE (); 12389 switch (op[2] & 0x00) 12390 { 12391 case 0x00: 12392 goto op_semantics_111; 12393 break; 12394 } 12395 break; 12396 case 0xb5: 12397 GETBYTE (); 12398 switch (op[2] & 0x00) 12399 { 12400 case 0x00: 12401 goto op_semantics_111; 12402 break; 12403 } 12404 break; 12405 case 0xb6: 12406 GETBYTE (); 12407 switch (op[2] & 0x00) 12408 { 12409 case 0x00: 12410 goto op_semantics_111; 12411 break; 12412 } 12413 break; 12414 case 0xb7: 12415 GETBYTE (); 12416 switch (op[2] & 0x00) 12417 { 12418 case 0x00: 12419 goto op_semantics_111; 12420 break; 12421 } 12422 break; 12423 case 0xb8: 12424 GETBYTE (); 12425 switch (op[2] & 0x00) 12426 { 12427 case 0x00: 12428 goto op_semantics_111; 12429 break; 12430 } 12431 break; 12432 case 0xb9: 12433 GETBYTE (); 12434 switch (op[2] & 0x00) 12435 { 12436 case 0x00: 12437 goto op_semantics_111; 12438 break; 12439 } 12440 break; 12441 case 0xba: 12442 GETBYTE (); 12443 switch (op[2] & 0x00) 12444 { 12445 case 0x00: 12446 goto op_semantics_111; 12447 break; 12448 } 12449 break; 12450 case 0xbb: 12451 GETBYTE (); 12452 switch (op[2] & 0x00) 12453 { 12454 case 0x00: 12455 goto op_semantics_111; 12456 break; 12457 } 12458 break; 12459 case 0xbc: 12460 GETBYTE (); 12461 switch (op[2] & 0x00) 12462 { 12463 case 0x00: 12464 goto op_semantics_111; 12465 break; 12466 } 12467 break; 12468 case 0xbd: 12469 GETBYTE (); 12470 switch (op[2] & 0x00) 12471 { 12472 case 0x00: 12473 goto op_semantics_111; 12474 break; 12475 } 12476 break; 12477 case 0xbe: 12478 GETBYTE (); 12479 switch (op[2] & 0x00) 12480 { 12481 case 0x00: 12482 goto op_semantics_111; 12483 break; 12484 } 12485 break; 12486 case 0xbf: 12487 GETBYTE (); 12488 switch (op[2] & 0x00) 12489 { 12490 case 0x00: 12491 goto op_semantics_111; 12492 break; 12493 } 12494 break; 12495 case 0xc0: 12496 GETBYTE (); 12497 switch (op[2] & 0x00) 12498 { 12499 case 0x00: 12500 op_semantics_112: 12501 { 12502 /** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */ 12503 #line 716 "rx-decode.opc" 12504 int immmm AU = op[1] & 0x1f; 12505 #line 716 "rx-decode.opc" 12506 int rsrc AU = (op[2] >> 4) & 0x0f; 12507 #line 716 "rx-decode.opc" 12508 int rdst AU = op[2] & 0x0f; 12509 if (trace) 12510 { 12511 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12512 "/** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */", 12513 op[0], op[1], op[2]); 12514 printf (" immmm = 0x%x,", immmm); 12515 printf (" rsrc = 0x%x,", rsrc); 12516 printf (" rdst = 0x%x\n", rdst); 12517 } 12518 SYNTAX("shll #%2, %1, %0"); 12519 #line 716 "rx-decode.opc" 12520 ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F_OSZC; 12521 12522 12523 } 12524 break; 12525 } 12526 break; 12527 case 0xc1: 12528 GETBYTE (); 12529 switch (op[2] & 0x00) 12530 { 12531 case 0x00: 12532 goto op_semantics_112; 12533 break; 12534 } 12535 break; 12536 case 0xc2: 12537 GETBYTE (); 12538 switch (op[2] & 0x00) 12539 { 12540 case 0x00: 12541 goto op_semantics_112; 12542 break; 12543 } 12544 break; 12545 case 0xc3: 12546 GETBYTE (); 12547 switch (op[2] & 0x00) 12548 { 12549 case 0x00: 12550 goto op_semantics_112; 12551 break; 12552 } 12553 break; 12554 case 0xc4: 12555 GETBYTE (); 12556 switch (op[2] & 0x00) 12557 { 12558 case 0x00: 12559 goto op_semantics_112; 12560 break; 12561 } 12562 break; 12563 case 0xc5: 12564 GETBYTE (); 12565 switch (op[2] & 0x00) 12566 { 12567 case 0x00: 12568 goto op_semantics_112; 12569 break; 12570 } 12571 break; 12572 case 0xc6: 12573 GETBYTE (); 12574 switch (op[2] & 0x00) 12575 { 12576 case 0x00: 12577 goto op_semantics_112; 12578 break; 12579 } 12580 break; 12581 case 0xc7: 12582 GETBYTE (); 12583 switch (op[2] & 0x00) 12584 { 12585 case 0x00: 12586 goto op_semantics_112; 12587 break; 12588 } 12589 break; 12590 case 0xc8: 12591 GETBYTE (); 12592 switch (op[2] & 0x00) 12593 { 12594 case 0x00: 12595 goto op_semantics_112; 12596 break; 12597 } 12598 break; 12599 case 0xc9: 12600 GETBYTE (); 12601 switch (op[2] & 0x00) 12602 { 12603 case 0x00: 12604 goto op_semantics_112; 12605 break; 12606 } 12607 break; 12608 case 0xca: 12609 GETBYTE (); 12610 switch (op[2] & 0x00) 12611 { 12612 case 0x00: 12613 goto op_semantics_112; 12614 break; 12615 } 12616 break; 12617 case 0xcb: 12618 GETBYTE (); 12619 switch (op[2] & 0x00) 12620 { 12621 case 0x00: 12622 goto op_semantics_112; 12623 break; 12624 } 12625 break; 12626 case 0xcc: 12627 GETBYTE (); 12628 switch (op[2] & 0x00) 12629 { 12630 case 0x00: 12631 goto op_semantics_112; 12632 break; 12633 } 12634 break; 12635 case 0xcd: 12636 GETBYTE (); 12637 switch (op[2] & 0x00) 12638 { 12639 case 0x00: 12640 goto op_semantics_112; 12641 break; 12642 } 12643 break; 12644 case 0xce: 12645 GETBYTE (); 12646 switch (op[2] & 0x00) 12647 { 12648 case 0x00: 12649 goto op_semantics_112; 12650 break; 12651 } 12652 break; 12653 case 0xcf: 12654 GETBYTE (); 12655 switch (op[2] & 0x00) 12656 { 12657 case 0x00: 12658 goto op_semantics_112; 12659 break; 12660 } 12661 break; 12662 case 0xd0: 12663 GETBYTE (); 12664 switch (op[2] & 0x00) 12665 { 12666 case 0x00: 12667 goto op_semantics_112; 12668 break; 12669 } 12670 break; 12671 case 0xd1: 12672 GETBYTE (); 12673 switch (op[2] & 0x00) 12674 { 12675 case 0x00: 12676 goto op_semantics_112; 12677 break; 12678 } 12679 break; 12680 case 0xd2: 12681 GETBYTE (); 12682 switch (op[2] & 0x00) 12683 { 12684 case 0x00: 12685 goto op_semantics_112; 12686 break; 12687 } 12688 break; 12689 case 0xd3: 12690 GETBYTE (); 12691 switch (op[2] & 0x00) 12692 { 12693 case 0x00: 12694 goto op_semantics_112; 12695 break; 12696 } 12697 break; 12698 case 0xd4: 12699 GETBYTE (); 12700 switch (op[2] & 0x00) 12701 { 12702 case 0x00: 12703 goto op_semantics_112; 12704 break; 12705 } 12706 break; 12707 case 0xd5: 12708 GETBYTE (); 12709 switch (op[2] & 0x00) 12710 { 12711 case 0x00: 12712 goto op_semantics_112; 12713 break; 12714 } 12715 break; 12716 case 0xd6: 12717 GETBYTE (); 12718 switch (op[2] & 0x00) 12719 { 12720 case 0x00: 12721 goto op_semantics_112; 12722 break; 12723 } 12724 break; 12725 case 0xd7: 12726 GETBYTE (); 12727 switch (op[2] & 0x00) 12728 { 12729 case 0x00: 12730 goto op_semantics_112; 12731 break; 12732 } 12733 break; 12734 case 0xd8: 12735 GETBYTE (); 12736 switch (op[2] & 0x00) 12737 { 12738 case 0x00: 12739 goto op_semantics_112; 12740 break; 12741 } 12742 break; 12743 case 0xd9: 12744 GETBYTE (); 12745 switch (op[2] & 0x00) 12746 { 12747 case 0x00: 12748 goto op_semantics_112; 12749 break; 12750 } 12751 break; 12752 case 0xda: 12753 GETBYTE (); 12754 switch (op[2] & 0x00) 12755 { 12756 case 0x00: 12757 goto op_semantics_112; 12758 break; 12759 } 12760 break; 12761 case 0xdb: 12762 GETBYTE (); 12763 switch (op[2] & 0x00) 12764 { 12765 case 0x00: 12766 goto op_semantics_112; 12767 break; 12768 } 12769 break; 12770 case 0xdc: 12771 GETBYTE (); 12772 switch (op[2] & 0x00) 12773 { 12774 case 0x00: 12775 goto op_semantics_112; 12776 break; 12777 } 12778 break; 12779 case 0xdd: 12780 GETBYTE (); 12781 switch (op[2] & 0x00) 12782 { 12783 case 0x00: 12784 goto op_semantics_112; 12785 break; 12786 } 12787 break; 12788 case 0xde: 12789 GETBYTE (); 12790 switch (op[2] & 0x00) 12791 { 12792 case 0x00: 12793 goto op_semantics_112; 12794 break; 12795 } 12796 break; 12797 case 0xdf: 12798 GETBYTE (); 12799 switch (op[2] & 0x00) 12800 { 12801 case 0x00: 12802 goto op_semantics_112; 12803 break; 12804 } 12805 break; 12806 case 0xe0: 12807 GETBYTE (); 12808 switch (op[2] & 0xf0) 12809 { 12810 case 0x00: 12811 case 0x10: 12812 case 0x20: 12813 case 0x30: 12814 case 0x40: 12815 case 0x50: 12816 case 0x60: 12817 case 0x70: 12818 case 0x80: 12819 case 0x90: 12820 case 0xa0: 12821 case 0xb0: 12822 case 0xc0: 12823 case 0xd0: 12824 case 0xe0: 12825 op_semantics_113: 12826 { 12827 /** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */ 12828 #line 990 "rx-decode.opc" 12829 int bittt AU = op[1] & 0x1f; 12830 #line 990 "rx-decode.opc" 12831 int cond AU = (op[2] >> 4) & 0x0f; 12832 #line 990 "rx-decode.opc" 12833 int rdst AU = op[2] & 0x0f; 12834 if (trace) 12835 { 12836 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12837 "/** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */", 12838 op[0], op[1], op[2]); 12839 printf (" bittt = 0x%x,", bittt); 12840 printf (" cond = 0x%x,", cond); 12841 printf (" rdst = 0x%x\n", rdst); 12842 } 12843 SYNTAX("bm%2 #%1, %0%S0"); 12844 #line 990 "rx-decode.opc" 12845 ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst); 12846 12847 /*----------------------------------------------------------------------*/ 12848 /* CONTROL REGISTERS */ 12849 12850 } 12851 break; 12852 case 0xf0: 12853 op_semantics_114: 12854 { 12855 /** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */ 12856 #line 983 "rx-decode.opc" 12857 int bittt AU = op[1] & 0x1f; 12858 #line 983 "rx-decode.opc" 12859 int rdst AU = op[2] & 0x0f; 12860 if (trace) 12861 { 12862 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12863 "/** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */", 12864 op[0], op[1], op[2]); 12865 printf (" bittt = 0x%x,", bittt); 12866 printf (" rdst = 0x%x\n", rdst); 12867 } 12868 SYNTAX("bnot #%1, %0"); 12869 #line 983 "rx-decode.opc" 12870 ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst); 12871 12872 12873 } 12874 break; 12875 } 12876 break; 12877 case 0xe1: 12878 GETBYTE (); 12879 switch (op[2] & 0xf0) 12880 { 12881 case 0x00: 12882 case 0x10: 12883 case 0x20: 12884 case 0x30: 12885 case 0x40: 12886 case 0x50: 12887 case 0x60: 12888 case 0x70: 12889 case 0x80: 12890 case 0x90: 12891 case 0xa0: 12892 case 0xb0: 12893 case 0xc0: 12894 case 0xd0: 12895 case 0xe0: 12896 goto op_semantics_113; 12897 break; 12898 case 0xf0: 12899 goto op_semantics_114; 12900 break; 12901 } 12902 break; 12903 case 0xe2: 12904 GETBYTE (); 12905 switch (op[2] & 0xf0) 12906 { 12907 case 0x00: 12908 case 0x10: 12909 case 0x20: 12910 case 0x30: 12911 case 0x40: 12912 case 0x50: 12913 case 0x60: 12914 case 0x70: 12915 case 0x80: 12916 case 0x90: 12917 case 0xa0: 12918 case 0xb0: 12919 case 0xc0: 12920 case 0xd0: 12921 case 0xe0: 12922 goto op_semantics_113; 12923 break; 12924 case 0xf0: 12925 goto op_semantics_114; 12926 break; 12927 } 12928 break; 12929 case 0xe3: 12930 GETBYTE (); 12931 switch (op[2] & 0xf0) 12932 { 12933 case 0x00: 12934 case 0x10: 12935 case 0x20: 12936 case 0x30: 12937 case 0x40: 12938 case 0x50: 12939 case 0x60: 12940 case 0x70: 12941 case 0x80: 12942 case 0x90: 12943 case 0xa0: 12944 case 0xb0: 12945 case 0xc0: 12946 case 0xd0: 12947 case 0xe0: 12948 goto op_semantics_113; 12949 break; 12950 case 0xf0: 12951 goto op_semantics_114; 12952 break; 12953 } 12954 break; 12955 case 0xe4: 12956 GETBYTE (); 12957 switch (op[2] & 0xf0) 12958 { 12959 case 0x00: 12960 case 0x10: 12961 case 0x20: 12962 case 0x30: 12963 case 0x40: 12964 case 0x50: 12965 case 0x60: 12966 case 0x70: 12967 case 0x80: 12968 case 0x90: 12969 case 0xa0: 12970 case 0xb0: 12971 case 0xc0: 12972 case 0xd0: 12973 case 0xe0: 12974 goto op_semantics_113; 12975 break; 12976 case 0xf0: 12977 goto op_semantics_114; 12978 break; 12979 } 12980 break; 12981 case 0xe5: 12982 GETBYTE (); 12983 switch (op[2] & 0xf0) 12984 { 12985 case 0x00: 12986 case 0x10: 12987 case 0x20: 12988 case 0x30: 12989 case 0x40: 12990 case 0x50: 12991 case 0x60: 12992 case 0x70: 12993 case 0x80: 12994 case 0x90: 12995 case 0xa0: 12996 case 0xb0: 12997 case 0xc0: 12998 case 0xd0: 12999 case 0xe0: 13000 goto op_semantics_113; 13001 break; 13002 case 0xf0: 13003 goto op_semantics_114; 13004 break; 13005 } 13006 break; 13007 case 0xe6: 13008 GETBYTE (); 13009 switch (op[2] & 0xf0) 13010 { 13011 case 0x00: 13012 case 0x10: 13013 case 0x20: 13014 case 0x30: 13015 case 0x40: 13016 case 0x50: 13017 case 0x60: 13018 case 0x70: 13019 case 0x80: 13020 case 0x90: 13021 case 0xa0: 13022 case 0xb0: 13023 case 0xc0: 13024 case 0xd0: 13025 case 0xe0: 13026 goto op_semantics_113; 13027 break; 13028 case 0xf0: 13029 goto op_semantics_114; 13030 break; 13031 } 13032 break; 13033 case 0xe7: 13034 GETBYTE (); 13035 switch (op[2] & 0xf0) 13036 { 13037 case 0x00: 13038 case 0x10: 13039 case 0x20: 13040 case 0x30: 13041 case 0x40: 13042 case 0x50: 13043 case 0x60: 13044 case 0x70: 13045 case 0x80: 13046 case 0x90: 13047 case 0xa0: 13048 case 0xb0: 13049 case 0xc0: 13050 case 0xd0: 13051 case 0xe0: 13052 goto op_semantics_113; 13053 break; 13054 case 0xf0: 13055 goto op_semantics_114; 13056 break; 13057 } 13058 break; 13059 case 0xe8: 13060 GETBYTE (); 13061 switch (op[2] & 0xf0) 13062 { 13063 case 0x00: 13064 case 0x10: 13065 case 0x20: 13066 case 0x30: 13067 case 0x40: 13068 case 0x50: 13069 case 0x60: 13070 case 0x70: 13071 case 0x80: 13072 case 0x90: 13073 case 0xa0: 13074 case 0xb0: 13075 case 0xc0: 13076 case 0xd0: 13077 case 0xe0: 13078 goto op_semantics_113; 13079 break; 13080 case 0xf0: 13081 goto op_semantics_114; 13082 break; 13083 } 13084 break; 13085 case 0xe9: 13086 GETBYTE (); 13087 switch (op[2] & 0xf0) 13088 { 13089 case 0x00: 13090 case 0x10: 13091 case 0x20: 13092 case 0x30: 13093 case 0x40: 13094 case 0x50: 13095 case 0x60: 13096 case 0x70: 13097 case 0x80: 13098 case 0x90: 13099 case 0xa0: 13100 case 0xb0: 13101 case 0xc0: 13102 case 0xd0: 13103 case 0xe0: 13104 goto op_semantics_113; 13105 break; 13106 case 0xf0: 13107 goto op_semantics_114; 13108 break; 13109 } 13110 break; 13111 case 0xea: 13112 GETBYTE (); 13113 switch (op[2] & 0xf0) 13114 { 13115 case 0x00: 13116 case 0x10: 13117 case 0x20: 13118 case 0x30: 13119 case 0x40: 13120 case 0x50: 13121 case 0x60: 13122 case 0x70: 13123 case 0x80: 13124 case 0x90: 13125 case 0xa0: 13126 case 0xb0: 13127 case 0xc0: 13128 case 0xd0: 13129 case 0xe0: 13130 goto op_semantics_113; 13131 break; 13132 case 0xf0: 13133 goto op_semantics_114; 13134 break; 13135 } 13136 break; 13137 case 0xeb: 13138 GETBYTE (); 13139 switch (op[2] & 0xf0) 13140 { 13141 case 0x00: 13142 case 0x10: 13143 case 0x20: 13144 case 0x30: 13145 case 0x40: 13146 case 0x50: 13147 case 0x60: 13148 case 0x70: 13149 case 0x80: 13150 case 0x90: 13151 case 0xa0: 13152 case 0xb0: 13153 case 0xc0: 13154 case 0xd0: 13155 case 0xe0: 13156 goto op_semantics_113; 13157 break; 13158 case 0xf0: 13159 goto op_semantics_114; 13160 break; 13161 } 13162 break; 13163 case 0xec: 13164 GETBYTE (); 13165 switch (op[2] & 0xf0) 13166 { 13167 case 0x00: 13168 case 0x10: 13169 case 0x20: 13170 case 0x30: 13171 case 0x40: 13172 case 0x50: 13173 case 0x60: 13174 case 0x70: 13175 case 0x80: 13176 case 0x90: 13177 case 0xa0: 13178 case 0xb0: 13179 case 0xc0: 13180 case 0xd0: 13181 case 0xe0: 13182 goto op_semantics_113; 13183 break; 13184 case 0xf0: 13185 goto op_semantics_114; 13186 break; 13187 } 13188 break; 13189 case 0xed: 13190 GETBYTE (); 13191 switch (op[2] & 0xf0) 13192 { 13193 case 0x00: 13194 case 0x10: 13195 case 0x20: 13196 case 0x30: 13197 case 0x40: 13198 case 0x50: 13199 case 0x60: 13200 case 0x70: 13201 case 0x80: 13202 case 0x90: 13203 case 0xa0: 13204 case 0xb0: 13205 case 0xc0: 13206 case 0xd0: 13207 case 0xe0: 13208 goto op_semantics_113; 13209 break; 13210 case 0xf0: 13211 goto op_semantics_114; 13212 break; 13213 } 13214 break; 13215 case 0xee: 13216 GETBYTE (); 13217 switch (op[2] & 0xf0) 13218 { 13219 case 0x00: 13220 case 0x10: 13221 case 0x20: 13222 case 0x30: 13223 case 0x40: 13224 case 0x50: 13225 case 0x60: 13226 case 0x70: 13227 case 0x80: 13228 case 0x90: 13229 case 0xa0: 13230 case 0xb0: 13231 case 0xc0: 13232 case 0xd0: 13233 case 0xe0: 13234 goto op_semantics_113; 13235 break; 13236 case 0xf0: 13237 goto op_semantics_114; 13238 break; 13239 } 13240 break; 13241 case 0xef: 13242 GETBYTE (); 13243 switch (op[2] & 0xf0) 13244 { 13245 case 0x00: 13246 case 0x10: 13247 case 0x20: 13248 case 0x30: 13249 case 0x40: 13250 case 0x50: 13251 case 0x60: 13252 case 0x70: 13253 case 0x80: 13254 case 0x90: 13255 case 0xa0: 13256 case 0xb0: 13257 case 0xc0: 13258 case 0xd0: 13259 case 0xe0: 13260 goto op_semantics_113; 13261 break; 13262 case 0xf0: 13263 goto op_semantics_114; 13264 break; 13265 } 13266 break; 13267 case 0xf0: 13268 GETBYTE (); 13269 switch (op[2] & 0xf0) 13270 { 13271 case 0x00: 13272 case 0x10: 13273 case 0x20: 13274 case 0x30: 13275 case 0x40: 13276 case 0x50: 13277 case 0x60: 13278 case 0x70: 13279 case 0x80: 13280 case 0x90: 13281 case 0xa0: 13282 case 0xb0: 13283 case 0xc0: 13284 case 0xd0: 13285 case 0xe0: 13286 goto op_semantics_113; 13287 break; 13288 case 0xf0: 13289 goto op_semantics_114; 13290 break; 13291 } 13292 break; 13293 case 0xf1: 13294 GETBYTE (); 13295 switch (op[2] & 0xf0) 13296 { 13297 case 0x00: 13298 case 0x10: 13299 case 0x20: 13300 case 0x30: 13301 case 0x40: 13302 case 0x50: 13303 case 0x60: 13304 case 0x70: 13305 case 0x80: 13306 case 0x90: 13307 case 0xa0: 13308 case 0xb0: 13309 case 0xc0: 13310 case 0xd0: 13311 case 0xe0: 13312 goto op_semantics_113; 13313 break; 13314 case 0xf0: 13315 goto op_semantics_114; 13316 break; 13317 } 13318 break; 13319 case 0xf2: 13320 GETBYTE (); 13321 switch (op[2] & 0xf0) 13322 { 13323 case 0x00: 13324 case 0x10: 13325 case 0x20: 13326 case 0x30: 13327 case 0x40: 13328 case 0x50: 13329 case 0x60: 13330 case 0x70: 13331 case 0x80: 13332 case 0x90: 13333 case 0xa0: 13334 case 0xb0: 13335 case 0xc0: 13336 case 0xd0: 13337 case 0xe0: 13338 goto op_semantics_113; 13339 break; 13340 case 0xf0: 13341 goto op_semantics_114; 13342 break; 13343 } 13344 break; 13345 case 0xf3: 13346 GETBYTE (); 13347 switch (op[2] & 0xf0) 13348 { 13349 case 0x00: 13350 case 0x10: 13351 case 0x20: 13352 case 0x30: 13353 case 0x40: 13354 case 0x50: 13355 case 0x60: 13356 case 0x70: 13357 case 0x80: 13358 case 0x90: 13359 case 0xa0: 13360 case 0xb0: 13361 case 0xc0: 13362 case 0xd0: 13363 case 0xe0: 13364 goto op_semantics_113; 13365 break; 13366 case 0xf0: 13367 goto op_semantics_114; 13368 break; 13369 } 13370 break; 13371 case 0xf4: 13372 GETBYTE (); 13373 switch (op[2] & 0xf0) 13374 { 13375 case 0x00: 13376 case 0x10: 13377 case 0x20: 13378 case 0x30: 13379 case 0x40: 13380 case 0x50: 13381 case 0x60: 13382 case 0x70: 13383 case 0x80: 13384 case 0x90: 13385 case 0xa0: 13386 case 0xb0: 13387 case 0xc0: 13388 case 0xd0: 13389 case 0xe0: 13390 goto op_semantics_113; 13391 break; 13392 case 0xf0: 13393 goto op_semantics_114; 13394 break; 13395 } 13396 break; 13397 case 0xf5: 13398 GETBYTE (); 13399 switch (op[2] & 0xf0) 13400 { 13401 case 0x00: 13402 case 0x10: 13403 case 0x20: 13404 case 0x30: 13405 case 0x40: 13406 case 0x50: 13407 case 0x60: 13408 case 0x70: 13409 case 0x80: 13410 case 0x90: 13411 case 0xa0: 13412 case 0xb0: 13413 case 0xc0: 13414 case 0xd0: 13415 case 0xe0: 13416 goto op_semantics_113; 13417 break; 13418 case 0xf0: 13419 goto op_semantics_114; 13420 break; 13421 } 13422 break; 13423 case 0xf6: 13424 GETBYTE (); 13425 switch (op[2] & 0xf0) 13426 { 13427 case 0x00: 13428 case 0x10: 13429 case 0x20: 13430 case 0x30: 13431 case 0x40: 13432 case 0x50: 13433 case 0x60: 13434 case 0x70: 13435 case 0x80: 13436 case 0x90: 13437 case 0xa0: 13438 case 0xb0: 13439 case 0xc0: 13440 case 0xd0: 13441 case 0xe0: 13442 goto op_semantics_113; 13443 break; 13444 case 0xf0: 13445 goto op_semantics_114; 13446 break; 13447 } 13448 break; 13449 case 0xf7: 13450 GETBYTE (); 13451 switch (op[2] & 0xf0) 13452 { 13453 case 0x00: 13454 case 0x10: 13455 case 0x20: 13456 case 0x30: 13457 case 0x40: 13458 case 0x50: 13459 case 0x60: 13460 case 0x70: 13461 case 0x80: 13462 case 0x90: 13463 case 0xa0: 13464 case 0xb0: 13465 case 0xc0: 13466 case 0xd0: 13467 case 0xe0: 13468 goto op_semantics_113; 13469 break; 13470 case 0xf0: 13471 goto op_semantics_114; 13472 break; 13473 } 13474 break; 13475 case 0xf8: 13476 GETBYTE (); 13477 switch (op[2] & 0xf0) 13478 { 13479 case 0x00: 13480 case 0x10: 13481 case 0x20: 13482 case 0x30: 13483 case 0x40: 13484 case 0x50: 13485 case 0x60: 13486 case 0x70: 13487 case 0x80: 13488 case 0x90: 13489 case 0xa0: 13490 case 0xb0: 13491 case 0xc0: 13492 case 0xd0: 13493 case 0xe0: 13494 goto op_semantics_113; 13495 break; 13496 case 0xf0: 13497 goto op_semantics_114; 13498 break; 13499 } 13500 break; 13501 case 0xf9: 13502 GETBYTE (); 13503 switch (op[2] & 0xf0) 13504 { 13505 case 0x00: 13506 case 0x10: 13507 case 0x20: 13508 case 0x30: 13509 case 0x40: 13510 case 0x50: 13511 case 0x60: 13512 case 0x70: 13513 case 0x80: 13514 case 0x90: 13515 case 0xa0: 13516 case 0xb0: 13517 case 0xc0: 13518 case 0xd0: 13519 case 0xe0: 13520 goto op_semantics_113; 13521 break; 13522 case 0xf0: 13523 goto op_semantics_114; 13524 break; 13525 } 13526 break; 13527 case 0xfa: 13528 GETBYTE (); 13529 switch (op[2] & 0xf0) 13530 { 13531 case 0x00: 13532 case 0x10: 13533 case 0x20: 13534 case 0x30: 13535 case 0x40: 13536 case 0x50: 13537 case 0x60: 13538 case 0x70: 13539 case 0x80: 13540 case 0x90: 13541 case 0xa0: 13542 case 0xb0: 13543 case 0xc0: 13544 case 0xd0: 13545 case 0xe0: 13546 goto op_semantics_113; 13547 break; 13548 case 0xf0: 13549 goto op_semantics_114; 13550 break; 13551 } 13552 break; 13553 case 0xfb: 13554 GETBYTE (); 13555 switch (op[2] & 0xf0) 13556 { 13557 case 0x00: 13558 case 0x10: 13559 case 0x20: 13560 case 0x30: 13561 case 0x40: 13562 case 0x50: 13563 case 0x60: 13564 case 0x70: 13565 case 0x80: 13566 case 0x90: 13567 case 0xa0: 13568 case 0xb0: 13569 case 0xc0: 13570 case 0xd0: 13571 case 0xe0: 13572 goto op_semantics_113; 13573 break; 13574 case 0xf0: 13575 goto op_semantics_114; 13576 break; 13577 } 13578 break; 13579 case 0xfc: 13580 GETBYTE (); 13581 switch (op[2] & 0xf0) 13582 { 13583 case 0x00: 13584 case 0x10: 13585 case 0x20: 13586 case 0x30: 13587 case 0x40: 13588 case 0x50: 13589 case 0x60: 13590 case 0x70: 13591 case 0x80: 13592 case 0x90: 13593 case 0xa0: 13594 case 0xb0: 13595 case 0xc0: 13596 case 0xd0: 13597 case 0xe0: 13598 goto op_semantics_113; 13599 break; 13600 case 0xf0: 13601 goto op_semantics_114; 13602 break; 13603 } 13604 break; 13605 case 0xfd: 13606 GETBYTE (); 13607 switch (op[2] & 0xf0) 13608 { 13609 case 0x00: 13610 case 0x10: 13611 case 0x20: 13612 case 0x30: 13613 case 0x40: 13614 case 0x50: 13615 case 0x60: 13616 case 0x70: 13617 case 0x80: 13618 case 0x90: 13619 case 0xa0: 13620 case 0xb0: 13621 case 0xc0: 13622 case 0xd0: 13623 case 0xe0: 13624 goto op_semantics_113; 13625 break; 13626 case 0xf0: 13627 goto op_semantics_114; 13628 break; 13629 } 13630 break; 13631 case 0xfe: 13632 GETBYTE (); 13633 switch (op[2] & 0xf0) 13634 { 13635 case 0x00: 13636 case 0x10: 13637 case 0x20: 13638 case 0x30: 13639 case 0x40: 13640 case 0x50: 13641 case 0x60: 13642 case 0x70: 13643 case 0x80: 13644 case 0x90: 13645 case 0xa0: 13646 case 0xb0: 13647 case 0xc0: 13648 case 0xd0: 13649 case 0xe0: 13650 goto op_semantics_113; 13651 break; 13652 case 0xf0: 13653 goto op_semantics_114; 13654 break; 13655 } 13656 break; 13657 case 0xff: 13658 GETBYTE (); 13659 switch (op[2] & 0xf0) 13660 { 13661 case 0x00: 13662 case 0x10: 13663 case 0x20: 13664 case 0x30: 13665 case 0x40: 13666 case 0x50: 13667 case 0x60: 13668 case 0x70: 13669 case 0x80: 13670 case 0x90: 13671 case 0xa0: 13672 case 0xb0: 13673 case 0xc0: 13674 case 0xd0: 13675 case 0xe0: 13676 goto op_semantics_113; 13677 break; 13678 case 0xf0: 13679 goto op_semantics_114; 13680 break; 13681 } 13682 break; 13683 default: UNSUPPORTED(); break; 13684 } 13685 break; 13686 case 0xfe: 13687 GETBYTE (); 13688 switch (op[1] & 0xff) 13689 { 13690 case 0x00: 13691 GETBYTE (); 13692 switch (op[2] & 0x00) 13693 { 13694 case 0x00: 13695 op_semantics_115: 13696 { 13697 /** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */ 13698 #line 342 "rx-decode.opc" 13699 int sz AU = (op[1] >> 4) & 0x03; 13700 #line 342 "rx-decode.opc" 13701 int isrc AU = op[1] & 0x0f; 13702 #line 342 "rx-decode.opc" 13703 int bsrc AU = (op[2] >> 4) & 0x0f; 13704 #line 342 "rx-decode.opc" 13705 int rdst AU = op[2] & 0x0f; 13706 if (trace) 13707 { 13708 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13709 "/** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */", 13710 op[0], op[1], op[2]); 13711 printf (" sz = 0x%x,", sz); 13712 printf (" isrc = 0x%x,", isrc); 13713 printf (" bsrc = 0x%x,", bsrc); 13714 printf (" rdst = 0x%x\n", rdst); 13715 } 13716 SYNTAX("mov%s %0, [%1, %2]"); 13717 #line 342 "rx-decode.opc" 13718 ID(movbir); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____; 13719 13720 } 13721 break; 13722 } 13723 break; 13724 case 0x01: 13725 GETBYTE (); 13726 switch (op[2] & 0x00) 13727 { 13728 case 0x00: 13729 goto op_semantics_115; 13730 break; 13731 } 13732 break; 13733 case 0x02: 13734 GETBYTE (); 13735 switch (op[2] & 0x00) 13736 { 13737 case 0x00: 13738 goto op_semantics_115; 13739 break; 13740 } 13741 break; 13742 case 0x03: 13743 GETBYTE (); 13744 switch (op[2] & 0x00) 13745 { 13746 case 0x00: 13747 goto op_semantics_115; 13748 break; 13749 } 13750 break; 13751 case 0x04: 13752 GETBYTE (); 13753 switch (op[2] & 0x00) 13754 { 13755 case 0x00: 13756 goto op_semantics_115; 13757 break; 13758 } 13759 break; 13760 case 0x05: 13761 GETBYTE (); 13762 switch (op[2] & 0x00) 13763 { 13764 case 0x00: 13765 goto op_semantics_115; 13766 break; 13767 } 13768 break; 13769 case 0x06: 13770 GETBYTE (); 13771 switch (op[2] & 0x00) 13772 { 13773 case 0x00: 13774 goto op_semantics_115; 13775 break; 13776 } 13777 break; 13778 case 0x07: 13779 GETBYTE (); 13780 switch (op[2] & 0x00) 13781 { 13782 case 0x00: 13783 goto op_semantics_115; 13784 break; 13785 } 13786 break; 13787 case 0x08: 13788 GETBYTE (); 13789 switch (op[2] & 0x00) 13790 { 13791 case 0x00: 13792 goto op_semantics_115; 13793 break; 13794 } 13795 break; 13796 case 0x09: 13797 GETBYTE (); 13798 switch (op[2] & 0x00) 13799 { 13800 case 0x00: 13801 goto op_semantics_115; 13802 break; 13803 } 13804 break; 13805 case 0x0a: 13806 GETBYTE (); 13807 switch (op[2] & 0x00) 13808 { 13809 case 0x00: 13810 goto op_semantics_115; 13811 break; 13812 } 13813 break; 13814 case 0x0b: 13815 GETBYTE (); 13816 switch (op[2] & 0x00) 13817 { 13818 case 0x00: 13819 goto op_semantics_115; 13820 break; 13821 } 13822 break; 13823 case 0x0c: 13824 GETBYTE (); 13825 switch (op[2] & 0x00) 13826 { 13827 case 0x00: 13828 goto op_semantics_115; 13829 break; 13830 } 13831 break; 13832 case 0x0d: 13833 GETBYTE (); 13834 switch (op[2] & 0x00) 13835 { 13836 case 0x00: 13837 goto op_semantics_115; 13838 break; 13839 } 13840 break; 13841 case 0x0e: 13842 GETBYTE (); 13843 switch (op[2] & 0x00) 13844 { 13845 case 0x00: 13846 goto op_semantics_115; 13847 break; 13848 } 13849 break; 13850 case 0x0f: 13851 GETBYTE (); 13852 switch (op[2] & 0x00) 13853 { 13854 case 0x00: 13855 goto op_semantics_115; 13856 break; 13857 } 13858 break; 13859 case 0x10: 13860 GETBYTE (); 13861 switch (op[2] & 0x00) 13862 { 13863 case 0x00: 13864 goto op_semantics_115; 13865 break; 13866 } 13867 break; 13868 case 0x11: 13869 GETBYTE (); 13870 switch (op[2] & 0x00) 13871 { 13872 case 0x00: 13873 goto op_semantics_115; 13874 break; 13875 } 13876 break; 13877 case 0x12: 13878 GETBYTE (); 13879 switch (op[2] & 0x00) 13880 { 13881 case 0x00: 13882 goto op_semantics_115; 13883 break; 13884 } 13885 break; 13886 case 0x13: 13887 GETBYTE (); 13888 switch (op[2] & 0x00) 13889 { 13890 case 0x00: 13891 goto op_semantics_115; 13892 break; 13893 } 13894 break; 13895 case 0x14: 13896 GETBYTE (); 13897 switch (op[2] & 0x00) 13898 { 13899 case 0x00: 13900 goto op_semantics_115; 13901 break; 13902 } 13903 break; 13904 case 0x15: 13905 GETBYTE (); 13906 switch (op[2] & 0x00) 13907 { 13908 case 0x00: 13909 goto op_semantics_115; 13910 break; 13911 } 13912 break; 13913 case 0x16: 13914 GETBYTE (); 13915 switch (op[2] & 0x00) 13916 { 13917 case 0x00: 13918 goto op_semantics_115; 13919 break; 13920 } 13921 break; 13922 case 0x17: 13923 GETBYTE (); 13924 switch (op[2] & 0x00) 13925 { 13926 case 0x00: 13927 goto op_semantics_115; 13928 break; 13929 } 13930 break; 13931 case 0x18: 13932 GETBYTE (); 13933 switch (op[2] & 0x00) 13934 { 13935 case 0x00: 13936 goto op_semantics_115; 13937 break; 13938 } 13939 break; 13940 case 0x19: 13941 GETBYTE (); 13942 switch (op[2] & 0x00) 13943 { 13944 case 0x00: 13945 goto op_semantics_115; 13946 break; 13947 } 13948 break; 13949 case 0x1a: 13950 GETBYTE (); 13951 switch (op[2] & 0x00) 13952 { 13953 case 0x00: 13954 goto op_semantics_115; 13955 break; 13956 } 13957 break; 13958 case 0x1b: 13959 GETBYTE (); 13960 switch (op[2] & 0x00) 13961 { 13962 case 0x00: 13963 goto op_semantics_115; 13964 break; 13965 } 13966 break; 13967 case 0x1c: 13968 GETBYTE (); 13969 switch (op[2] & 0x00) 13970 { 13971 case 0x00: 13972 goto op_semantics_115; 13973 break; 13974 } 13975 break; 13976 case 0x1d: 13977 GETBYTE (); 13978 switch (op[2] & 0x00) 13979 { 13980 case 0x00: 13981 goto op_semantics_115; 13982 break; 13983 } 13984 break; 13985 case 0x1e: 13986 GETBYTE (); 13987 switch (op[2] & 0x00) 13988 { 13989 case 0x00: 13990 goto op_semantics_115; 13991 break; 13992 } 13993 break; 13994 case 0x1f: 13995 GETBYTE (); 13996 switch (op[2] & 0x00) 13997 { 13998 case 0x00: 13999 goto op_semantics_115; 14000 break; 14001 } 14002 break; 14003 case 0x20: 14004 GETBYTE (); 14005 switch (op[2] & 0x00) 14006 { 14007 case 0x00: 14008 goto op_semantics_115; 14009 break; 14010 } 14011 break; 14012 case 0x21: 14013 GETBYTE (); 14014 switch (op[2] & 0x00) 14015 { 14016 case 0x00: 14017 goto op_semantics_115; 14018 break; 14019 } 14020 break; 14021 case 0x22: 14022 GETBYTE (); 14023 switch (op[2] & 0x00) 14024 { 14025 case 0x00: 14026 goto op_semantics_115; 14027 break; 14028 } 14029 break; 14030 case 0x23: 14031 GETBYTE (); 14032 switch (op[2] & 0x00) 14033 { 14034 case 0x00: 14035 goto op_semantics_115; 14036 break; 14037 } 14038 break; 14039 case 0x24: 14040 GETBYTE (); 14041 switch (op[2] & 0x00) 14042 { 14043 case 0x00: 14044 goto op_semantics_115; 14045 break; 14046 } 14047 break; 14048 case 0x25: 14049 GETBYTE (); 14050 switch (op[2] & 0x00) 14051 { 14052 case 0x00: 14053 goto op_semantics_115; 14054 break; 14055 } 14056 break; 14057 case 0x26: 14058 GETBYTE (); 14059 switch (op[2] & 0x00) 14060 { 14061 case 0x00: 14062 goto op_semantics_115; 14063 break; 14064 } 14065 break; 14066 case 0x27: 14067 GETBYTE (); 14068 switch (op[2] & 0x00) 14069 { 14070 case 0x00: 14071 goto op_semantics_115; 14072 break; 14073 } 14074 break; 14075 case 0x28: 14076 GETBYTE (); 14077 switch (op[2] & 0x00) 14078 { 14079 case 0x00: 14080 goto op_semantics_115; 14081 break; 14082 } 14083 break; 14084 case 0x29: 14085 GETBYTE (); 14086 switch (op[2] & 0x00) 14087 { 14088 case 0x00: 14089 goto op_semantics_115; 14090 break; 14091 } 14092 break; 14093 case 0x2a: 14094 GETBYTE (); 14095 switch (op[2] & 0x00) 14096 { 14097 case 0x00: 14098 goto op_semantics_115; 14099 break; 14100 } 14101 break; 14102 case 0x2b: 14103 GETBYTE (); 14104 switch (op[2] & 0x00) 14105 { 14106 case 0x00: 14107 goto op_semantics_115; 14108 break; 14109 } 14110 break; 14111 case 0x2c: 14112 GETBYTE (); 14113 switch (op[2] & 0x00) 14114 { 14115 case 0x00: 14116 goto op_semantics_115; 14117 break; 14118 } 14119 break; 14120 case 0x2d: 14121 GETBYTE (); 14122 switch (op[2] & 0x00) 14123 { 14124 case 0x00: 14125 goto op_semantics_115; 14126 break; 14127 } 14128 break; 14129 case 0x2e: 14130 GETBYTE (); 14131 switch (op[2] & 0x00) 14132 { 14133 case 0x00: 14134 goto op_semantics_115; 14135 break; 14136 } 14137 break; 14138 case 0x2f: 14139 GETBYTE (); 14140 switch (op[2] & 0x00) 14141 { 14142 case 0x00: 14143 goto op_semantics_115; 14144 break; 14145 } 14146 break; 14147 case 0x40: 14148 GETBYTE (); 14149 switch (op[2] & 0x00) 14150 { 14151 case 0x00: 14152 op_semantics_116: 14153 { 14154 /** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */ 14155 #line 339 "rx-decode.opc" 14156 int sz AU = (op[1] >> 4) & 0x03; 14157 #line 339 "rx-decode.opc" 14158 int isrc AU = op[1] & 0x0f; 14159 #line 339 "rx-decode.opc" 14160 int bsrc AU = (op[2] >> 4) & 0x0f; 14161 #line 339 "rx-decode.opc" 14162 int rdst AU = op[2] & 0x0f; 14163 if (trace) 14164 { 14165 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 14166 "/** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */", 14167 op[0], op[1], op[2]); 14168 printf (" sz = 0x%x,", sz); 14169 printf (" isrc = 0x%x,", isrc); 14170 printf (" bsrc = 0x%x,", bsrc); 14171 printf (" rdst = 0x%x\n", rdst); 14172 } 14173 SYNTAX("mov%s [%1, %2], %0"); 14174 #line 339 "rx-decode.opc" 14175 ID(movbi); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____; 14176 14177 } 14178 break; 14179 } 14180 break; 14181 case 0x41: 14182 GETBYTE (); 14183 switch (op[2] & 0x00) 14184 { 14185 case 0x00: 14186 goto op_semantics_116; 14187 break; 14188 } 14189 break; 14190 case 0x42: 14191 GETBYTE (); 14192 switch (op[2] & 0x00) 14193 { 14194 case 0x00: 14195 goto op_semantics_116; 14196 break; 14197 } 14198 break; 14199 case 0x43: 14200 GETBYTE (); 14201 switch (op[2] & 0x00) 14202 { 14203 case 0x00: 14204 goto op_semantics_116; 14205 break; 14206 } 14207 break; 14208 case 0x44: 14209 GETBYTE (); 14210 switch (op[2] & 0x00) 14211 { 14212 case 0x00: 14213 goto op_semantics_116; 14214 break; 14215 } 14216 break; 14217 case 0x45: 14218 GETBYTE (); 14219 switch (op[2] & 0x00) 14220 { 14221 case 0x00: 14222 goto op_semantics_116; 14223 break; 14224 } 14225 break; 14226 case 0x46: 14227 GETBYTE (); 14228 switch (op[2] & 0x00) 14229 { 14230 case 0x00: 14231 goto op_semantics_116; 14232 break; 14233 } 14234 break; 14235 case 0x47: 14236 GETBYTE (); 14237 switch (op[2] & 0x00) 14238 { 14239 case 0x00: 14240 goto op_semantics_116; 14241 break; 14242 } 14243 break; 14244 case 0x48: 14245 GETBYTE (); 14246 switch (op[2] & 0x00) 14247 { 14248 case 0x00: 14249 goto op_semantics_116; 14250 break; 14251 } 14252 break; 14253 case 0x49: 14254 GETBYTE (); 14255 switch (op[2] & 0x00) 14256 { 14257 case 0x00: 14258 goto op_semantics_116; 14259 break; 14260 } 14261 break; 14262 case 0x4a: 14263 GETBYTE (); 14264 switch (op[2] & 0x00) 14265 { 14266 case 0x00: 14267 goto op_semantics_116; 14268 break; 14269 } 14270 break; 14271 case 0x4b: 14272 GETBYTE (); 14273 switch (op[2] & 0x00) 14274 { 14275 case 0x00: 14276 goto op_semantics_116; 14277 break; 14278 } 14279 break; 14280 case 0x4c: 14281 GETBYTE (); 14282 switch (op[2] & 0x00) 14283 { 14284 case 0x00: 14285 goto op_semantics_116; 14286 break; 14287 } 14288 break; 14289 case 0x4d: 14290 GETBYTE (); 14291 switch (op[2] & 0x00) 14292 { 14293 case 0x00: 14294 goto op_semantics_116; 14295 break; 14296 } 14297 break; 14298 case 0x4e: 14299 GETBYTE (); 14300 switch (op[2] & 0x00) 14301 { 14302 case 0x00: 14303 goto op_semantics_116; 14304 break; 14305 } 14306 break; 14307 case 0x4f: 14308 GETBYTE (); 14309 switch (op[2] & 0x00) 14310 { 14311 case 0x00: 14312 goto op_semantics_116; 14313 break; 14314 } 14315 break; 14316 case 0x50: 14317 GETBYTE (); 14318 switch (op[2] & 0x00) 14319 { 14320 case 0x00: 14321 goto op_semantics_116; 14322 break; 14323 } 14324 break; 14325 case 0x51: 14326 GETBYTE (); 14327 switch (op[2] & 0x00) 14328 { 14329 case 0x00: 14330 goto op_semantics_116; 14331 break; 14332 } 14333 break; 14334 case 0x52: 14335 GETBYTE (); 14336 switch (op[2] & 0x00) 14337 { 14338 case 0x00: 14339 goto op_semantics_116; 14340 break; 14341 } 14342 break; 14343 case 0x53: 14344 GETBYTE (); 14345 switch (op[2] & 0x00) 14346 { 14347 case 0x00: 14348 goto op_semantics_116; 14349 break; 14350 } 14351 break; 14352 case 0x54: 14353 GETBYTE (); 14354 switch (op[2] & 0x00) 14355 { 14356 case 0x00: 14357 goto op_semantics_116; 14358 break; 14359 } 14360 break; 14361 case 0x55: 14362 GETBYTE (); 14363 switch (op[2] & 0x00) 14364 { 14365 case 0x00: 14366 goto op_semantics_116; 14367 break; 14368 } 14369 break; 14370 case 0x56: 14371 GETBYTE (); 14372 switch (op[2] & 0x00) 14373 { 14374 case 0x00: 14375 goto op_semantics_116; 14376 break; 14377 } 14378 break; 14379 case 0x57: 14380 GETBYTE (); 14381 switch (op[2] & 0x00) 14382 { 14383 case 0x00: 14384 goto op_semantics_116; 14385 break; 14386 } 14387 break; 14388 case 0x58: 14389 GETBYTE (); 14390 switch (op[2] & 0x00) 14391 { 14392 case 0x00: 14393 goto op_semantics_116; 14394 break; 14395 } 14396 break; 14397 case 0x59: 14398 GETBYTE (); 14399 switch (op[2] & 0x00) 14400 { 14401 case 0x00: 14402 goto op_semantics_116; 14403 break; 14404 } 14405 break; 14406 case 0x5a: 14407 GETBYTE (); 14408 switch (op[2] & 0x00) 14409 { 14410 case 0x00: 14411 goto op_semantics_116; 14412 break; 14413 } 14414 break; 14415 case 0x5b: 14416 GETBYTE (); 14417 switch (op[2] & 0x00) 14418 { 14419 case 0x00: 14420 goto op_semantics_116; 14421 break; 14422 } 14423 break; 14424 case 0x5c: 14425 GETBYTE (); 14426 switch (op[2] & 0x00) 14427 { 14428 case 0x00: 14429 goto op_semantics_116; 14430 break; 14431 } 14432 break; 14433 case 0x5d: 14434 GETBYTE (); 14435 switch (op[2] & 0x00) 14436 { 14437 case 0x00: 14438 goto op_semantics_116; 14439 break; 14440 } 14441 break; 14442 case 0x5e: 14443 GETBYTE (); 14444 switch (op[2] & 0x00) 14445 { 14446 case 0x00: 14447 goto op_semantics_116; 14448 break; 14449 } 14450 break; 14451 case 0x5f: 14452 GETBYTE (); 14453 switch (op[2] & 0x00) 14454 { 14455 case 0x00: 14456 goto op_semantics_116; 14457 break; 14458 } 14459 break; 14460 case 0x60: 14461 GETBYTE (); 14462 switch (op[2] & 0x00) 14463 { 14464 case 0x00: 14465 goto op_semantics_116; 14466 break; 14467 } 14468 break; 14469 case 0x61: 14470 GETBYTE (); 14471 switch (op[2] & 0x00) 14472 { 14473 case 0x00: 14474 goto op_semantics_116; 14475 break; 14476 } 14477 break; 14478 case 0x62: 14479 GETBYTE (); 14480 switch (op[2] & 0x00) 14481 { 14482 case 0x00: 14483 goto op_semantics_116; 14484 break; 14485 } 14486 break; 14487 case 0x63: 14488 GETBYTE (); 14489 switch (op[2] & 0x00) 14490 { 14491 case 0x00: 14492 goto op_semantics_116; 14493 break; 14494 } 14495 break; 14496 case 0x64: 14497 GETBYTE (); 14498 switch (op[2] & 0x00) 14499 { 14500 case 0x00: 14501 goto op_semantics_116; 14502 break; 14503 } 14504 break; 14505 case 0x65: 14506 GETBYTE (); 14507 switch (op[2] & 0x00) 14508 { 14509 case 0x00: 14510 goto op_semantics_116; 14511 break; 14512 } 14513 break; 14514 case 0x66: 14515 GETBYTE (); 14516 switch (op[2] & 0x00) 14517 { 14518 case 0x00: 14519 goto op_semantics_116; 14520 break; 14521 } 14522 break; 14523 case 0x67: 14524 GETBYTE (); 14525 switch (op[2] & 0x00) 14526 { 14527 case 0x00: 14528 goto op_semantics_116; 14529 break; 14530 } 14531 break; 14532 case 0x68: 14533 GETBYTE (); 14534 switch (op[2] & 0x00) 14535 { 14536 case 0x00: 14537 goto op_semantics_116; 14538 break; 14539 } 14540 break; 14541 case 0x69: 14542 GETBYTE (); 14543 switch (op[2] & 0x00) 14544 { 14545 case 0x00: 14546 goto op_semantics_116; 14547 break; 14548 } 14549 break; 14550 case 0x6a: 14551 GETBYTE (); 14552 switch (op[2] & 0x00) 14553 { 14554 case 0x00: 14555 goto op_semantics_116; 14556 break; 14557 } 14558 break; 14559 case 0x6b: 14560 GETBYTE (); 14561 switch (op[2] & 0x00) 14562 { 14563 case 0x00: 14564 goto op_semantics_116; 14565 break; 14566 } 14567 break; 14568 case 0x6c: 14569 GETBYTE (); 14570 switch (op[2] & 0x00) 14571 { 14572 case 0x00: 14573 goto op_semantics_116; 14574 break; 14575 } 14576 break; 14577 case 0x6d: 14578 GETBYTE (); 14579 switch (op[2] & 0x00) 14580 { 14581 case 0x00: 14582 goto op_semantics_116; 14583 break; 14584 } 14585 break; 14586 case 0x6e: 14587 GETBYTE (); 14588 switch (op[2] & 0x00) 14589 { 14590 case 0x00: 14591 goto op_semantics_116; 14592 break; 14593 } 14594 break; 14595 case 0x6f: 14596 GETBYTE (); 14597 switch (op[2] & 0x00) 14598 { 14599 case 0x00: 14600 goto op_semantics_116; 14601 break; 14602 } 14603 break; 14604 case 0xc0: 14605 GETBYTE (); 14606 switch (op[2] & 0x00) 14607 { 14608 case 0x00: 14609 op_semantics_117: 14610 { 14611 /** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */ 14612 #line 345 "rx-decode.opc" 14613 int sz AU = (op[1] >> 4) & 0x03; 14614 #line 345 "rx-decode.opc" 14615 int isrc AU = op[1] & 0x0f; 14616 #line 345 "rx-decode.opc" 14617 int bsrc AU = (op[2] >> 4) & 0x0f; 14618 #line 345 "rx-decode.opc" 14619 int rdst AU = op[2] & 0x0f; 14620 if (trace) 14621 { 14622 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 14623 "/** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */", 14624 op[0], op[1], op[2]); 14625 printf (" sz = 0x%x,", sz); 14626 printf (" isrc = 0x%x,", isrc); 14627 printf (" bsrc = 0x%x,", bsrc); 14628 printf (" rdst = 0x%x\n", rdst); 14629 } 14630 SYNTAX("movu%s [%1, %2], %0"); 14631 #line 345 "rx-decode.opc" 14632 ID(movbi); uBW(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____; 14633 14634 } 14635 break; 14636 } 14637 break; 14638 case 0xc1: 14639 GETBYTE (); 14640 switch (op[2] & 0x00) 14641 { 14642 case 0x00: 14643 goto op_semantics_117; 14644 break; 14645 } 14646 break; 14647 case 0xc2: 14648 GETBYTE (); 14649 switch (op[2] & 0x00) 14650 { 14651 case 0x00: 14652 goto op_semantics_117; 14653 break; 14654 } 14655 break; 14656 case 0xc3: 14657 GETBYTE (); 14658 switch (op[2] & 0x00) 14659 { 14660 case 0x00: 14661 goto op_semantics_117; 14662 break; 14663 } 14664 break; 14665 case 0xc4: 14666 GETBYTE (); 14667 switch (op[2] & 0x00) 14668 { 14669 case 0x00: 14670 goto op_semantics_117; 14671 break; 14672 } 14673 break; 14674 case 0xc5: 14675 GETBYTE (); 14676 switch (op[2] & 0x00) 14677 { 14678 case 0x00: 14679 goto op_semantics_117; 14680 break; 14681 } 14682 break; 14683 case 0xc6: 14684 GETBYTE (); 14685 switch (op[2] & 0x00) 14686 { 14687 case 0x00: 14688 goto op_semantics_117; 14689 break; 14690 } 14691 break; 14692 case 0xc7: 14693 GETBYTE (); 14694 switch (op[2] & 0x00) 14695 { 14696 case 0x00: 14697 goto op_semantics_117; 14698 break; 14699 } 14700 break; 14701 case 0xc8: 14702 GETBYTE (); 14703 switch (op[2] & 0x00) 14704 { 14705 case 0x00: 14706 goto op_semantics_117; 14707 break; 14708 } 14709 break; 14710 case 0xc9: 14711 GETBYTE (); 14712 switch (op[2] & 0x00) 14713 { 14714 case 0x00: 14715 goto op_semantics_117; 14716 break; 14717 } 14718 break; 14719 case 0xca: 14720 GETBYTE (); 14721 switch (op[2] & 0x00) 14722 { 14723 case 0x00: 14724 goto op_semantics_117; 14725 break; 14726 } 14727 break; 14728 case 0xcb: 14729 GETBYTE (); 14730 switch (op[2] & 0x00) 14731 { 14732 case 0x00: 14733 goto op_semantics_117; 14734 break; 14735 } 14736 break; 14737 case 0xcc: 14738 GETBYTE (); 14739 switch (op[2] & 0x00) 14740 { 14741 case 0x00: 14742 goto op_semantics_117; 14743 break; 14744 } 14745 break; 14746 case 0xcd: 14747 GETBYTE (); 14748 switch (op[2] & 0x00) 14749 { 14750 case 0x00: 14751 goto op_semantics_117; 14752 break; 14753 } 14754 break; 14755 case 0xce: 14756 GETBYTE (); 14757 switch (op[2] & 0x00) 14758 { 14759 case 0x00: 14760 goto op_semantics_117; 14761 break; 14762 } 14763 break; 14764 case 0xcf: 14765 GETBYTE (); 14766 switch (op[2] & 0x00) 14767 { 14768 case 0x00: 14769 goto op_semantics_117; 14770 break; 14771 } 14772 break; 14773 case 0xd0: 14774 GETBYTE (); 14775 switch (op[2] & 0x00) 14776 { 14777 case 0x00: 14778 goto op_semantics_117; 14779 break; 14780 } 14781 break; 14782 case 0xd1: 14783 GETBYTE (); 14784 switch (op[2] & 0x00) 14785 { 14786 case 0x00: 14787 goto op_semantics_117; 14788 break; 14789 } 14790 break; 14791 case 0xd2: 14792 GETBYTE (); 14793 switch (op[2] & 0x00) 14794 { 14795 case 0x00: 14796 goto op_semantics_117; 14797 break; 14798 } 14799 break; 14800 case 0xd3: 14801 GETBYTE (); 14802 switch (op[2] & 0x00) 14803 { 14804 case 0x00: 14805 goto op_semantics_117; 14806 break; 14807 } 14808 break; 14809 case 0xd4: 14810 GETBYTE (); 14811 switch (op[2] & 0x00) 14812 { 14813 case 0x00: 14814 goto op_semantics_117; 14815 break; 14816 } 14817 break; 14818 case 0xd5: 14819 GETBYTE (); 14820 switch (op[2] & 0x00) 14821 { 14822 case 0x00: 14823 goto op_semantics_117; 14824 break; 14825 } 14826 break; 14827 case 0xd6: 14828 GETBYTE (); 14829 switch (op[2] & 0x00) 14830 { 14831 case 0x00: 14832 goto op_semantics_117; 14833 break; 14834 } 14835 break; 14836 case 0xd7: 14837 GETBYTE (); 14838 switch (op[2] & 0x00) 14839 { 14840 case 0x00: 14841 goto op_semantics_117; 14842 break; 14843 } 14844 break; 14845 case 0xd8: 14846 GETBYTE (); 14847 switch (op[2] & 0x00) 14848 { 14849 case 0x00: 14850 goto op_semantics_117; 14851 break; 14852 } 14853 break; 14854 case 0xd9: 14855 GETBYTE (); 14856 switch (op[2] & 0x00) 14857 { 14858 case 0x00: 14859 goto op_semantics_117; 14860 break; 14861 } 14862 break; 14863 case 0xda: 14864 GETBYTE (); 14865 switch (op[2] & 0x00) 14866 { 14867 case 0x00: 14868 goto op_semantics_117; 14869 break; 14870 } 14871 break; 14872 case 0xdb: 14873 GETBYTE (); 14874 switch (op[2] & 0x00) 14875 { 14876 case 0x00: 14877 goto op_semantics_117; 14878 break; 14879 } 14880 break; 14881 case 0xdc: 14882 GETBYTE (); 14883 switch (op[2] & 0x00) 14884 { 14885 case 0x00: 14886 goto op_semantics_117; 14887 break; 14888 } 14889 break; 14890 case 0xdd: 14891 GETBYTE (); 14892 switch (op[2] & 0x00) 14893 { 14894 case 0x00: 14895 goto op_semantics_117; 14896 break; 14897 } 14898 break; 14899 case 0xde: 14900 GETBYTE (); 14901 switch (op[2] & 0x00) 14902 { 14903 case 0x00: 14904 goto op_semantics_117; 14905 break; 14906 } 14907 break; 14908 case 0xdf: 14909 GETBYTE (); 14910 switch (op[2] & 0x00) 14911 { 14912 case 0x00: 14913 goto op_semantics_117; 14914 break; 14915 } 14916 break; 14917 case 0xe0: 14918 GETBYTE (); 14919 switch (op[2] & 0x00) 14920 { 14921 case 0x00: 14922 goto op_semantics_117; 14923 break; 14924 } 14925 break; 14926 case 0xe1: 14927 GETBYTE (); 14928 switch (op[2] & 0x00) 14929 { 14930 case 0x00: 14931 goto op_semantics_117; 14932 break; 14933 } 14934 break; 14935 case 0xe2: 14936 GETBYTE (); 14937 switch (op[2] & 0x00) 14938 { 14939 case 0x00: 14940 goto op_semantics_117; 14941 break; 14942 } 14943 break; 14944 case 0xe3: 14945 GETBYTE (); 14946 switch (op[2] & 0x00) 14947 { 14948 case 0x00: 14949 goto op_semantics_117; 14950 break; 14951 } 14952 break; 14953 case 0xe4: 14954 GETBYTE (); 14955 switch (op[2] & 0x00) 14956 { 14957 case 0x00: 14958 goto op_semantics_117; 14959 break; 14960 } 14961 break; 14962 case 0xe5: 14963 GETBYTE (); 14964 switch (op[2] & 0x00) 14965 { 14966 case 0x00: 14967 goto op_semantics_117; 14968 break; 14969 } 14970 break; 14971 case 0xe6: 14972 GETBYTE (); 14973 switch (op[2] & 0x00) 14974 { 14975 case 0x00: 14976 goto op_semantics_117; 14977 break; 14978 } 14979 break; 14980 case 0xe7: 14981 GETBYTE (); 14982 switch (op[2] & 0x00) 14983 { 14984 case 0x00: 14985 goto op_semantics_117; 14986 break; 14987 } 14988 break; 14989 case 0xe8: 14990 GETBYTE (); 14991 switch (op[2] & 0x00) 14992 { 14993 case 0x00: 14994 goto op_semantics_117; 14995 break; 14996 } 14997 break; 14998 case 0xe9: 14999 GETBYTE (); 15000 switch (op[2] & 0x00) 15001 { 15002 case 0x00: 15003 goto op_semantics_117; 15004 break; 15005 } 15006 break; 15007 case 0xea: 15008 GETBYTE (); 15009 switch (op[2] & 0x00) 15010 { 15011 case 0x00: 15012 goto op_semantics_117; 15013 break; 15014 } 15015 break; 15016 case 0xeb: 15017 GETBYTE (); 15018 switch (op[2] & 0x00) 15019 { 15020 case 0x00: 15021 goto op_semantics_117; 15022 break; 15023 } 15024 break; 15025 case 0xec: 15026 GETBYTE (); 15027 switch (op[2] & 0x00) 15028 { 15029 case 0x00: 15030 goto op_semantics_117; 15031 break; 15032 } 15033 break; 15034 case 0xed: 15035 GETBYTE (); 15036 switch (op[2] & 0x00) 15037 { 15038 case 0x00: 15039 goto op_semantics_117; 15040 break; 15041 } 15042 break; 15043 case 0xee: 15044 GETBYTE (); 15045 switch (op[2] & 0x00) 15046 { 15047 case 0x00: 15048 goto op_semantics_117; 15049 break; 15050 } 15051 break; 15052 case 0xef: 15053 GETBYTE (); 15054 switch (op[2] & 0x00) 15055 { 15056 case 0x00: 15057 goto op_semantics_117; 15058 break; 15059 } 15060 break; 15061 default: UNSUPPORTED(); break; 15062 } 15063 break; 15064 case 0xff: 15065 GETBYTE (); 15066 switch (op[1] & 0xff) 15067 { 15068 case 0x00: 15069 GETBYTE (); 15070 switch (op[2] & 0x00) 15071 { 15072 case 0x00: 15073 op_semantics_118: 15074 { 15075 /** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */ 15076 #line 549 "rx-decode.opc" 15077 int rdst AU = op[1] & 0x0f; 15078 #line 549 "rx-decode.opc" 15079 int srca AU = (op[2] >> 4) & 0x0f; 15080 #line 549 "rx-decode.opc" 15081 int srcb AU = op[2] & 0x0f; 15082 if (trace) 15083 { 15084 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 15085 "/** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */", 15086 op[0], op[1], op[2]); 15087 printf (" rdst = 0x%x,", rdst); 15088 printf (" srca = 0x%x,", srca); 15089 printf (" srcb = 0x%x\n", srcb); 15090 } 15091 SYNTAX("sub %2, %1, %0"); 15092 #line 549 "rx-decode.opc" 15093 ID(sub); DR(rdst); SR(srcb); S2R(srca); F_OSZC; 15094 15095 /*----------------------------------------------------------------------*/ 15096 /* SBB */ 15097 15098 } 15099 break; 15100 } 15101 break; 15102 case 0x01: 15103 GETBYTE (); 15104 switch (op[2] & 0x00) 15105 { 15106 case 0x00: 15107 goto op_semantics_118; 15108 break; 15109 } 15110 break; 15111 case 0x02: 15112 GETBYTE (); 15113 switch (op[2] & 0x00) 15114 { 15115 case 0x00: 15116 goto op_semantics_118; 15117 break; 15118 } 15119 break; 15120 case 0x03: 15121 GETBYTE (); 15122 switch (op[2] & 0x00) 15123 { 15124 case 0x00: 15125 goto op_semantics_118; 15126 break; 15127 } 15128 break; 15129 case 0x04: 15130 GETBYTE (); 15131 switch (op[2] & 0x00) 15132 { 15133 case 0x00: 15134 goto op_semantics_118; 15135 break; 15136 } 15137 break; 15138 case 0x05: 15139 GETBYTE (); 15140 switch (op[2] & 0x00) 15141 { 15142 case 0x00: 15143 goto op_semantics_118; 15144 break; 15145 } 15146 break; 15147 case 0x06: 15148 GETBYTE (); 15149 switch (op[2] & 0x00) 15150 { 15151 case 0x00: 15152 goto op_semantics_118; 15153 break; 15154 } 15155 break; 15156 case 0x07: 15157 GETBYTE (); 15158 switch (op[2] & 0x00) 15159 { 15160 case 0x00: 15161 goto op_semantics_118; 15162 break; 15163 } 15164 break; 15165 case 0x08: 15166 GETBYTE (); 15167 switch (op[2] & 0x00) 15168 { 15169 case 0x00: 15170 goto op_semantics_118; 15171 break; 15172 } 15173 break; 15174 case 0x09: 15175 GETBYTE (); 15176 switch (op[2] & 0x00) 15177 { 15178 case 0x00: 15179 goto op_semantics_118; 15180 break; 15181 } 15182 break; 15183 case 0x0a: 15184 GETBYTE (); 15185 switch (op[2] & 0x00) 15186 { 15187 case 0x00: 15188 goto op_semantics_118; 15189 break; 15190 } 15191 break; 15192 case 0x0b: 15193 GETBYTE (); 15194 switch (op[2] & 0x00) 15195 { 15196 case 0x00: 15197 goto op_semantics_118; 15198 break; 15199 } 15200 break; 15201 case 0x0c: 15202 GETBYTE (); 15203 switch (op[2] & 0x00) 15204 { 15205 case 0x00: 15206 goto op_semantics_118; 15207 break; 15208 } 15209 break; 15210 case 0x0d: 15211 GETBYTE (); 15212 switch (op[2] & 0x00) 15213 { 15214 case 0x00: 15215 goto op_semantics_118; 15216 break; 15217 } 15218 break; 15219 case 0x0e: 15220 GETBYTE (); 15221 switch (op[2] & 0x00) 15222 { 15223 case 0x00: 15224 goto op_semantics_118; 15225 break; 15226 } 15227 break; 15228 case 0x0f: 15229 GETBYTE (); 15230 switch (op[2] & 0x00) 15231 { 15232 case 0x00: 15233 goto op_semantics_118; 15234 break; 15235 } 15236 break; 15237 case 0x20: 15238 GETBYTE (); 15239 switch (op[2] & 0x00) 15240 { 15241 case 0x00: 15242 op_semantics_119: 15243 { 15244 /** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */ 15245 #line 516 "rx-decode.opc" 15246 int rdst AU = op[1] & 0x0f; 15247 #line 516 "rx-decode.opc" 15248 int srca AU = (op[2] >> 4) & 0x0f; 15249 #line 516 "rx-decode.opc" 15250 int srcb AU = op[2] & 0x0f; 15251 if (trace) 15252 { 15253 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 15254 "/** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */", 15255 op[0], op[1], op[2]); 15256 printf (" rdst = 0x%x,", rdst); 15257 printf (" srca = 0x%x,", srca); 15258 printf (" srcb = 0x%x\n", srcb); 15259 } 15260 SYNTAX("add %2, %1, %0"); 15261 #line 516 "rx-decode.opc" 15262 ID(add); DR(rdst); SR(srcb); S2R(srca); F_OSZC; 15263 15264 /*----------------------------------------------------------------------*/ 15265 /* CMP */ 15266 15267 } 15268 break; 15269 } 15270 break; 15271 case 0x21: 15272 GETBYTE (); 15273 switch (op[2] & 0x00) 15274 { 15275 case 0x00: 15276 goto op_semantics_119; 15277 break; 15278 } 15279 break; 15280 case 0x22: 15281 GETBYTE (); 15282 switch (op[2] & 0x00) 15283 { 15284 case 0x00: 15285 goto op_semantics_119; 15286 break; 15287 } 15288 break; 15289 case 0x23: 15290 GETBYTE (); 15291 switch (op[2] & 0x00) 15292 { 15293 case 0x00: 15294 goto op_semantics_119; 15295 break; 15296 } 15297 break; 15298 case 0x24: 15299 GETBYTE (); 15300 switch (op[2] & 0x00) 15301 { 15302 case 0x00: 15303 goto op_semantics_119; 15304 break; 15305 } 15306 break; 15307 case 0x25: 15308 GETBYTE (); 15309 switch (op[2] & 0x00) 15310 { 15311 case 0x00: 15312 goto op_semantics_119; 15313 break; 15314 } 15315 break; 15316 case 0x26: 15317 GETBYTE (); 15318 switch (op[2] & 0x00) 15319 { 15320 case 0x00: 15321 goto op_semantics_119; 15322 break; 15323 } 15324 break; 15325 case 0x27: 15326 GETBYTE (); 15327 switch (op[2] & 0x00) 15328 { 15329 case 0x00: 15330 goto op_semantics_119; 15331 break; 15332 } 15333 break; 15334 case 0x28: 15335 GETBYTE (); 15336 switch (op[2] & 0x00) 15337 { 15338 case 0x00: 15339 goto op_semantics_119; 15340 break; 15341 } 15342 break; 15343 case 0x29: 15344 GETBYTE (); 15345 switch (op[2] & 0x00) 15346 { 15347 case 0x00: 15348 goto op_semantics_119; 15349 break; 15350 } 15351 break; 15352 case 0x2a: 15353 GETBYTE (); 15354 switch (op[2] & 0x00) 15355 { 15356 case 0x00: 15357 goto op_semantics_119; 15358 break; 15359 } 15360 break; 15361 case 0x2b: 15362 GETBYTE (); 15363 switch (op[2] & 0x00) 15364 { 15365 case 0x00: 15366 goto op_semantics_119; 15367 break; 15368 } 15369 break; 15370 case 0x2c: 15371 GETBYTE (); 15372 switch (op[2] & 0x00) 15373 { 15374 case 0x00: 15375 goto op_semantics_119; 15376 break; 15377 } 15378 break; 15379 case 0x2d: 15380 GETBYTE (); 15381 switch (op[2] & 0x00) 15382 { 15383 case 0x00: 15384 goto op_semantics_119; 15385 break; 15386 } 15387 break; 15388 case 0x2e: 15389 GETBYTE (); 15390 switch (op[2] & 0x00) 15391 { 15392 case 0x00: 15393 goto op_semantics_119; 15394 break; 15395 } 15396 break; 15397 case 0x2f: 15398 GETBYTE (); 15399 switch (op[2] & 0x00) 15400 { 15401 case 0x00: 15402 goto op_semantics_119; 15403 break; 15404 } 15405 break; 15406 case 0x30: 15407 GETBYTE (); 15408 switch (op[2] & 0x00) 15409 { 15410 case 0x00: 15411 op_semantics_120: 15412 { 15413 /** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */ 15414 #line 656 "rx-decode.opc" 15415 int rdst AU = op[1] & 0x0f; 15416 #line 656 "rx-decode.opc" 15417 int srca AU = (op[2] >> 4) & 0x0f; 15418 #line 656 "rx-decode.opc" 15419 int srcb AU = op[2] & 0x0f; 15420 if (trace) 15421 { 15422 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 15423 "/** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */", 15424 op[0], op[1], op[2]); 15425 printf (" rdst = 0x%x,", rdst); 15426 printf (" srca = 0x%x,", srca); 15427 printf (" srcb = 0x%x\n", srcb); 15428 } 15429 SYNTAX("mul %2, %1, %0"); 15430 #line 656 "rx-decode.opc" 15431 ID(mul); DR(rdst); SR(srcb); S2R(srca); F_____; 15432 15433 /*----------------------------------------------------------------------*/ 15434 /* EMUL */ 15435 15436 } 15437 break; 15438 } 15439 break; 15440 case 0x31: 15441 GETBYTE (); 15442 switch (op[2] & 0x00) 15443 { 15444 case 0x00: 15445 goto op_semantics_120; 15446 break; 15447 } 15448 break; 15449 case 0x32: 15450 GETBYTE (); 15451 switch (op[2] & 0x00) 15452 { 15453 case 0x00: 15454 goto op_semantics_120; 15455 break; 15456 } 15457 break; 15458 case 0x33: 15459 GETBYTE (); 15460 switch (op[2] & 0x00) 15461 { 15462 case 0x00: 15463 goto op_semantics_120; 15464 break; 15465 } 15466 break; 15467 case 0x34: 15468 GETBYTE (); 15469 switch (op[2] & 0x00) 15470 { 15471 case 0x00: 15472 goto op_semantics_120; 15473 break; 15474 } 15475 break; 15476 case 0x35: 15477 GETBYTE (); 15478 switch (op[2] & 0x00) 15479 { 15480 case 0x00: 15481 goto op_semantics_120; 15482 break; 15483 } 15484 break; 15485 case 0x36: 15486 GETBYTE (); 15487 switch (op[2] & 0x00) 15488 { 15489 case 0x00: 15490 goto op_semantics_120; 15491 break; 15492 } 15493 break; 15494 case 0x37: 15495 GETBYTE (); 15496 switch (op[2] & 0x00) 15497 { 15498 case 0x00: 15499 goto op_semantics_120; 15500 break; 15501 } 15502 break; 15503 case 0x38: 15504 GETBYTE (); 15505 switch (op[2] & 0x00) 15506 { 15507 case 0x00: 15508 goto op_semantics_120; 15509 break; 15510 } 15511 break; 15512 case 0x39: 15513 GETBYTE (); 15514 switch (op[2] & 0x00) 15515 { 15516 case 0x00: 15517 goto op_semantics_120; 15518 break; 15519 } 15520 break; 15521 case 0x3a: 15522 GETBYTE (); 15523 switch (op[2] & 0x00) 15524 { 15525 case 0x00: 15526 goto op_semantics_120; 15527 break; 15528 } 15529 break; 15530 case 0x3b: 15531 GETBYTE (); 15532 switch (op[2] & 0x00) 15533 { 15534 case 0x00: 15535 goto op_semantics_120; 15536 break; 15537 } 15538 break; 15539 case 0x3c: 15540 GETBYTE (); 15541 switch (op[2] & 0x00) 15542 { 15543 case 0x00: 15544 goto op_semantics_120; 15545 break; 15546 } 15547 break; 15548 case 0x3d: 15549 GETBYTE (); 15550 switch (op[2] & 0x00) 15551 { 15552 case 0x00: 15553 goto op_semantics_120; 15554 break; 15555 } 15556 break; 15557 case 0x3e: 15558 GETBYTE (); 15559 switch (op[2] & 0x00) 15560 { 15561 case 0x00: 15562 goto op_semantics_120; 15563 break; 15564 } 15565 break; 15566 case 0x3f: 15567 GETBYTE (); 15568 switch (op[2] & 0x00) 15569 { 15570 case 0x00: 15571 goto op_semantics_120; 15572 break; 15573 } 15574 break; 15575 case 0x40: 15576 GETBYTE (); 15577 switch (op[2] & 0x00) 15578 { 15579 case 0x00: 15580 op_semantics_121: 15581 { 15582 /** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */ 15583 #line 426 "rx-decode.opc" 15584 int rdst AU = op[1] & 0x0f; 15585 #line 426 "rx-decode.opc" 15586 int srca AU = (op[2] >> 4) & 0x0f; 15587 #line 426 "rx-decode.opc" 15588 int srcb AU = op[2] & 0x0f; 15589 if (trace) 15590 { 15591 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 15592 "/** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */", 15593 op[0], op[1], op[2]); 15594 printf (" rdst = 0x%x,", rdst); 15595 printf (" srca = 0x%x,", srca); 15596 printf (" srcb = 0x%x\n", srcb); 15597 } 15598 SYNTAX("and %2, %1, %0"); 15599 #line 426 "rx-decode.opc" 15600 ID(and); DR(rdst); SR(srcb); S2R(srca); F__SZ_; 15601 15602 /*----------------------------------------------------------------------*/ 15603 /* OR */ 15604 15605 } 15606 break; 15607 } 15608 break; 15609 case 0x41: 15610 GETBYTE (); 15611 switch (op[2] & 0x00) 15612 { 15613 case 0x00: 15614 goto op_semantics_121; 15615 break; 15616 } 15617 break; 15618 case 0x42: 15619 GETBYTE (); 15620 switch (op[2] & 0x00) 15621 { 15622 case 0x00: 15623 goto op_semantics_121; 15624 break; 15625 } 15626 break; 15627 case 0x43: 15628 GETBYTE (); 15629 switch (op[2] & 0x00) 15630 { 15631 case 0x00: 15632 goto op_semantics_121; 15633 break; 15634 } 15635 break; 15636 case 0x44: 15637 GETBYTE (); 15638 switch (op[2] & 0x00) 15639 { 15640 case 0x00: 15641 goto op_semantics_121; 15642 break; 15643 } 15644 break; 15645 case 0x45: 15646 GETBYTE (); 15647 switch (op[2] & 0x00) 15648 { 15649 case 0x00: 15650 goto op_semantics_121; 15651 break; 15652 } 15653 break; 15654 case 0x46: 15655 GETBYTE (); 15656 switch (op[2] & 0x00) 15657 { 15658 case 0x00: 15659 goto op_semantics_121; 15660 break; 15661 } 15662 break; 15663 case 0x47: 15664 GETBYTE (); 15665 switch (op[2] & 0x00) 15666 { 15667 case 0x00: 15668 goto op_semantics_121; 15669 break; 15670 } 15671 break; 15672 case 0x48: 15673 GETBYTE (); 15674 switch (op[2] & 0x00) 15675 { 15676 case 0x00: 15677 goto op_semantics_121; 15678 break; 15679 } 15680 break; 15681 case 0x49: 15682 GETBYTE (); 15683 switch (op[2] & 0x00) 15684 { 15685 case 0x00: 15686 goto op_semantics_121; 15687 break; 15688 } 15689 break; 15690 case 0x4a: 15691 GETBYTE (); 15692 switch (op[2] & 0x00) 15693 { 15694 case 0x00: 15695 goto op_semantics_121; 15696 break; 15697 } 15698 break; 15699 case 0x4b: 15700 GETBYTE (); 15701 switch (op[2] & 0x00) 15702 { 15703 case 0x00: 15704 goto op_semantics_121; 15705 break; 15706 } 15707 break; 15708 case 0x4c: 15709 GETBYTE (); 15710 switch (op[2] & 0x00) 15711 { 15712 case 0x00: 15713 goto op_semantics_121; 15714 break; 15715 } 15716 break; 15717 case 0x4d: 15718 GETBYTE (); 15719 switch (op[2] & 0x00) 15720 { 15721 case 0x00: 15722 goto op_semantics_121; 15723 break; 15724 } 15725 break; 15726 case 0x4e: 15727 GETBYTE (); 15728 switch (op[2] & 0x00) 15729 { 15730 case 0x00: 15731 goto op_semantics_121; 15732 break; 15733 } 15734 break; 15735 case 0x4f: 15736 GETBYTE (); 15737 switch (op[2] & 0x00) 15738 { 15739 case 0x00: 15740 goto op_semantics_121; 15741 break; 15742 } 15743 break; 15744 case 0x50: 15745 GETBYTE (); 15746 switch (op[2] & 0x00) 15747 { 15748 case 0x00: 15749 op_semantics_122: 15750 { 15751 /** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */ 15752 #line 444 "rx-decode.opc" 15753 int rdst AU = op[1] & 0x0f; 15754 #line 444 "rx-decode.opc" 15755 int srca AU = (op[2] >> 4) & 0x0f; 15756 #line 444 "rx-decode.opc" 15757 int srcb AU = op[2] & 0x0f; 15758 if (trace) 15759 { 15760 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 15761 "/** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */", 15762 op[0], op[1], op[2]); 15763 printf (" rdst = 0x%x,", rdst); 15764 printf (" srca = 0x%x,", srca); 15765 printf (" srcb = 0x%x\n", srcb); 15766 } 15767 SYNTAX("or %2, %1, %0"); 15768 #line 444 "rx-decode.opc" 15769 ID(or); DR(rdst); SR(srcb); S2R(srca); F__SZ_; 15770 15771 /*----------------------------------------------------------------------*/ 15772 /* XOR */ 15773 15774 } 15775 break; 15776 } 15777 break; 15778 case 0x51: 15779 GETBYTE (); 15780 switch (op[2] & 0x00) 15781 { 15782 case 0x00: 15783 goto op_semantics_122; 15784 break; 15785 } 15786 break; 15787 case 0x52: 15788 GETBYTE (); 15789 switch (op[2] & 0x00) 15790 { 15791 case 0x00: 15792 goto op_semantics_122; 15793 break; 15794 } 15795 break; 15796 case 0x53: 15797 GETBYTE (); 15798 switch (op[2] & 0x00) 15799 { 15800 case 0x00: 15801 goto op_semantics_122; 15802 break; 15803 } 15804 break; 15805 case 0x54: 15806 GETBYTE (); 15807 switch (op[2] & 0x00) 15808 { 15809 case 0x00: 15810 goto op_semantics_122; 15811 break; 15812 } 15813 break; 15814 case 0x55: 15815 GETBYTE (); 15816 switch (op[2] & 0x00) 15817 { 15818 case 0x00: 15819 goto op_semantics_122; 15820 break; 15821 } 15822 break; 15823 case 0x56: 15824 GETBYTE (); 15825 switch (op[2] & 0x00) 15826 { 15827 case 0x00: 15828 goto op_semantics_122; 15829 break; 15830 } 15831 break; 15832 case 0x57: 15833 GETBYTE (); 15834 switch (op[2] & 0x00) 15835 { 15836 case 0x00: 15837 goto op_semantics_122; 15838 break; 15839 } 15840 break; 15841 case 0x58: 15842 GETBYTE (); 15843 switch (op[2] & 0x00) 15844 { 15845 case 0x00: 15846 goto op_semantics_122; 15847 break; 15848 } 15849 break; 15850 case 0x59: 15851 GETBYTE (); 15852 switch (op[2] & 0x00) 15853 { 15854 case 0x00: 15855 goto op_semantics_122; 15856 break; 15857 } 15858 break; 15859 case 0x5a: 15860 GETBYTE (); 15861 switch (op[2] & 0x00) 15862 { 15863 case 0x00: 15864 goto op_semantics_122; 15865 break; 15866 } 15867 break; 15868 case 0x5b: 15869 GETBYTE (); 15870 switch (op[2] & 0x00) 15871 { 15872 case 0x00: 15873 goto op_semantics_122; 15874 break; 15875 } 15876 break; 15877 case 0x5c: 15878 GETBYTE (); 15879 switch (op[2] & 0x00) 15880 { 15881 case 0x00: 15882 goto op_semantics_122; 15883 break; 15884 } 15885 break; 15886 case 0x5d: 15887 GETBYTE (); 15888 switch (op[2] & 0x00) 15889 { 15890 case 0x00: 15891 goto op_semantics_122; 15892 break; 15893 } 15894 break; 15895 case 0x5e: 15896 GETBYTE (); 15897 switch (op[2] & 0x00) 15898 { 15899 case 0x00: 15900 goto op_semantics_122; 15901 break; 15902 } 15903 break; 15904 case 0x5f: 15905 GETBYTE (); 15906 switch (op[2] & 0x00) 15907 { 15908 case 0x00: 15909 goto op_semantics_122; 15910 break; 15911 } 15912 break; 15913 case 0x80: 15914 GETBYTE (); 15915 switch (op[2] & 0x00) 15916 { 15917 case 0x00: 15918 op_semantics_123: 15919 { 15920 /** 1111 1111 1000 rdst srca srcb fsub %2, %1, %0 */ 15921 #line 1104 "rx-decode.opc" 15922 int rdst AU = op[1] & 0x0f; 15923 #line 1104 "rx-decode.opc" 15924 int srca AU = (op[2] >> 4) & 0x0f; 15925 #line 1104 "rx-decode.opc" 15926 int srcb AU = op[2] & 0x0f; 15927 if (trace) 15928 { 15929 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 15930 "/** 1111 1111 1000 rdst srca srcb fsub %2, %1, %0 */", 15931 op[0], op[1], op[2]); 15932 printf (" rdst = 0x%x,", rdst); 15933 printf (" srca = 0x%x,", srca); 15934 printf (" srcb = 0x%x\n", srcb); 15935 } 15936 SYNTAX("fsub %2, %1, %0"); 15937 #line 1104 "rx-decode.opc" 15938 ID(fsub); DR(rdst); SR(srcb); S2R(srca); F__SZ_; 15939 15940 } 15941 break; 15942 } 15943 break; 15944 case 0x81: 15945 GETBYTE (); 15946 switch (op[2] & 0x00) 15947 { 15948 case 0x00: 15949 goto op_semantics_123; 15950 break; 15951 } 15952 break; 15953 case 0x82: 15954 GETBYTE (); 15955 switch (op[2] & 0x00) 15956 { 15957 case 0x00: 15958 goto op_semantics_123; 15959 break; 15960 } 15961 break; 15962 case 0x83: 15963 GETBYTE (); 15964 switch (op[2] & 0x00) 15965 { 15966 case 0x00: 15967 goto op_semantics_123; 15968 break; 15969 } 15970 break; 15971 case 0x84: 15972 GETBYTE (); 15973 switch (op[2] & 0x00) 15974 { 15975 case 0x00: 15976 goto op_semantics_123; 15977 break; 15978 } 15979 break; 15980 case 0x85: 15981 GETBYTE (); 15982 switch (op[2] & 0x00) 15983 { 15984 case 0x00: 15985 goto op_semantics_123; 15986 break; 15987 } 15988 break; 15989 case 0x86: 15990 GETBYTE (); 15991 switch (op[2] & 0x00) 15992 { 15993 case 0x00: 15994 goto op_semantics_123; 15995 break; 15996 } 15997 break; 15998 case 0x87: 15999 GETBYTE (); 16000 switch (op[2] & 0x00) 16001 { 16002 case 0x00: 16003 goto op_semantics_123; 16004 break; 16005 } 16006 break; 16007 case 0x88: 16008 GETBYTE (); 16009 switch (op[2] & 0x00) 16010 { 16011 case 0x00: 16012 goto op_semantics_123; 16013 break; 16014 } 16015 break; 16016 case 0x89: 16017 GETBYTE (); 16018 switch (op[2] & 0x00) 16019 { 16020 case 0x00: 16021 goto op_semantics_123; 16022 break; 16023 } 16024 break; 16025 case 0x8a: 16026 GETBYTE (); 16027 switch (op[2] & 0x00) 16028 { 16029 case 0x00: 16030 goto op_semantics_123; 16031 break; 16032 } 16033 break; 16034 case 0x8b: 16035 GETBYTE (); 16036 switch (op[2] & 0x00) 16037 { 16038 case 0x00: 16039 goto op_semantics_123; 16040 break; 16041 } 16042 break; 16043 case 0x8c: 16044 GETBYTE (); 16045 switch (op[2] & 0x00) 16046 { 16047 case 0x00: 16048 goto op_semantics_123; 16049 break; 16050 } 16051 break; 16052 case 0x8d: 16053 GETBYTE (); 16054 switch (op[2] & 0x00) 16055 { 16056 case 0x00: 16057 goto op_semantics_123; 16058 break; 16059 } 16060 break; 16061 case 0x8e: 16062 GETBYTE (); 16063 switch (op[2] & 0x00) 16064 { 16065 case 0x00: 16066 goto op_semantics_123; 16067 break; 16068 } 16069 break; 16070 case 0x8f: 16071 GETBYTE (); 16072 switch (op[2] & 0x00) 16073 { 16074 case 0x00: 16075 goto op_semantics_123; 16076 break; 16077 } 16078 break; 16079 case 0xa0: 16080 GETBYTE (); 16081 switch (op[2] & 0x00) 16082 { 16083 case 0x00: 16084 op_semantics_124: 16085 { 16086 /** 1111 1111 1010 rdst srca srcb fadd %2, %1, %0 */ 16087 #line 1101 "rx-decode.opc" 16088 int rdst AU = op[1] & 0x0f; 16089 #line 1101 "rx-decode.opc" 16090 int srca AU = (op[2] >> 4) & 0x0f; 16091 #line 1101 "rx-decode.opc" 16092 int srcb AU = op[2] & 0x0f; 16093 if (trace) 16094 { 16095 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 16096 "/** 1111 1111 1010 rdst srca srcb fadd %2, %1, %0 */", 16097 op[0], op[1], op[2]); 16098 printf (" rdst = 0x%x,", rdst); 16099 printf (" srca = 0x%x,", srca); 16100 printf (" srcb = 0x%x\n", srcb); 16101 } 16102 SYNTAX("fadd %2, %1, %0"); 16103 #line 1101 "rx-decode.opc" 16104 ID(fadd); DR(rdst); SR(srcb); S2R(srca); F__SZ_; 16105 16106 } 16107 break; 16108 } 16109 break; 16110 case 0xa1: 16111 GETBYTE (); 16112 switch (op[2] & 0x00) 16113 { 16114 case 0x00: 16115 goto op_semantics_124; 16116 break; 16117 } 16118 break; 16119 case 0xa2: 16120 GETBYTE (); 16121 switch (op[2] & 0x00) 16122 { 16123 case 0x00: 16124 goto op_semantics_124; 16125 break; 16126 } 16127 break; 16128 case 0xa3: 16129 GETBYTE (); 16130 switch (op[2] & 0x00) 16131 { 16132 case 0x00: 16133 goto op_semantics_124; 16134 break; 16135 } 16136 break; 16137 case 0xa4: 16138 GETBYTE (); 16139 switch (op[2] & 0x00) 16140 { 16141 case 0x00: 16142 goto op_semantics_124; 16143 break; 16144 } 16145 break; 16146 case 0xa5: 16147 GETBYTE (); 16148 switch (op[2] & 0x00) 16149 { 16150 case 0x00: 16151 goto op_semantics_124; 16152 break; 16153 } 16154 break; 16155 case 0xa6: 16156 GETBYTE (); 16157 switch (op[2] & 0x00) 16158 { 16159 case 0x00: 16160 goto op_semantics_124; 16161 break; 16162 } 16163 break; 16164 case 0xa7: 16165 GETBYTE (); 16166 switch (op[2] & 0x00) 16167 { 16168 case 0x00: 16169 goto op_semantics_124; 16170 break; 16171 } 16172 break; 16173 case 0xa8: 16174 GETBYTE (); 16175 switch (op[2] & 0x00) 16176 { 16177 case 0x00: 16178 goto op_semantics_124; 16179 break; 16180 } 16181 break; 16182 case 0xa9: 16183 GETBYTE (); 16184 switch (op[2] & 0x00) 16185 { 16186 case 0x00: 16187 goto op_semantics_124; 16188 break; 16189 } 16190 break; 16191 case 0xaa: 16192 GETBYTE (); 16193 switch (op[2] & 0x00) 16194 { 16195 case 0x00: 16196 goto op_semantics_124; 16197 break; 16198 } 16199 break; 16200 case 0xab: 16201 GETBYTE (); 16202 switch (op[2] & 0x00) 16203 { 16204 case 0x00: 16205 goto op_semantics_124; 16206 break; 16207 } 16208 break; 16209 case 0xac: 16210 GETBYTE (); 16211 switch (op[2] & 0x00) 16212 { 16213 case 0x00: 16214 goto op_semantics_124; 16215 break; 16216 } 16217 break; 16218 case 0xad: 16219 GETBYTE (); 16220 switch (op[2] & 0x00) 16221 { 16222 case 0x00: 16223 goto op_semantics_124; 16224 break; 16225 } 16226 break; 16227 case 0xae: 16228 GETBYTE (); 16229 switch (op[2] & 0x00) 16230 { 16231 case 0x00: 16232 goto op_semantics_124; 16233 break; 16234 } 16235 break; 16236 case 0xaf: 16237 GETBYTE (); 16238 switch (op[2] & 0x00) 16239 { 16240 case 0x00: 16241 goto op_semantics_124; 16242 break; 16243 } 16244 break; 16245 case 0xb0: 16246 GETBYTE (); 16247 switch (op[2] & 0x00) 16248 { 16249 case 0x00: 16250 op_semantics_125: 16251 { 16252 /** 1111 1111 1011 rdst srca srcb fmul %2, %1, %0 */ 16253 #line 1107 "rx-decode.opc" 16254 int rdst AU = op[1] & 0x0f; 16255 #line 1107 "rx-decode.opc" 16256 int srca AU = (op[2] >> 4) & 0x0f; 16257 #line 1107 "rx-decode.opc" 16258 int srcb AU = op[2] & 0x0f; 16259 if (trace) 16260 { 16261 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 16262 "/** 1111 1111 1011 rdst srca srcb fmul %2, %1, %0 */", 16263 op[0], op[1], op[2]); 16264 printf (" rdst = 0x%x,", rdst); 16265 printf (" srca = 0x%x,", srca); 16266 printf (" srcb = 0x%x\n", srcb); 16267 } 16268 SYNTAX("fmul %2, %1, %0"); 16269 #line 1107 "rx-decode.opc" 16270 ID(fmul); DR(rdst); SR(srcb); S2R(srca); F__SZ_; 16271 16272 } 16273 break; 16274 } 16275 break; 16276 case 0xb1: 16277 GETBYTE (); 16278 switch (op[2] & 0x00) 16279 { 16280 case 0x00: 16281 goto op_semantics_125; 16282 break; 16283 } 16284 break; 16285 case 0xb2: 16286 GETBYTE (); 16287 switch (op[2] & 0x00) 16288 { 16289 case 0x00: 16290 goto op_semantics_125; 16291 break; 16292 } 16293 break; 16294 case 0xb3: 16295 GETBYTE (); 16296 switch (op[2] & 0x00) 16297 { 16298 case 0x00: 16299 goto op_semantics_125; 16300 break; 16301 } 16302 break; 16303 case 0xb4: 16304 GETBYTE (); 16305 switch (op[2] & 0x00) 16306 { 16307 case 0x00: 16308 goto op_semantics_125; 16309 break; 16310 } 16311 break; 16312 case 0xb5: 16313 GETBYTE (); 16314 switch (op[2] & 0x00) 16315 { 16316 case 0x00: 16317 goto op_semantics_125; 16318 break; 16319 } 16320 break; 16321 case 0xb6: 16322 GETBYTE (); 16323 switch (op[2] & 0x00) 16324 { 16325 case 0x00: 16326 goto op_semantics_125; 16327 break; 16328 } 16329 break; 16330 case 0xb7: 16331 GETBYTE (); 16332 switch (op[2] & 0x00) 16333 { 16334 case 0x00: 16335 goto op_semantics_125; 16336 break; 16337 } 16338 break; 16339 case 0xb8: 16340 GETBYTE (); 16341 switch (op[2] & 0x00) 16342 { 16343 case 0x00: 16344 goto op_semantics_125; 16345 break; 16346 } 16347 break; 16348 case 0xb9: 16349 GETBYTE (); 16350 switch (op[2] & 0x00) 16351 { 16352 case 0x00: 16353 goto op_semantics_125; 16354 break; 16355 } 16356 break; 16357 case 0xba: 16358 GETBYTE (); 16359 switch (op[2] & 0x00) 16360 { 16361 case 0x00: 16362 goto op_semantics_125; 16363 break; 16364 } 16365 break; 16366 case 0xbb: 16367 GETBYTE (); 16368 switch (op[2] & 0x00) 16369 { 16370 case 0x00: 16371 goto op_semantics_125; 16372 break; 16373 } 16374 break; 16375 case 0xbc: 16376 GETBYTE (); 16377 switch (op[2] & 0x00) 16378 { 16379 case 0x00: 16380 goto op_semantics_125; 16381 break; 16382 } 16383 break; 16384 case 0xbd: 16385 GETBYTE (); 16386 switch (op[2] & 0x00) 16387 { 16388 case 0x00: 16389 goto op_semantics_125; 16390 break; 16391 } 16392 break; 16393 case 0xbe: 16394 GETBYTE (); 16395 switch (op[2] & 0x00) 16396 { 16397 case 0x00: 16398 goto op_semantics_125; 16399 break; 16400 } 16401 break; 16402 case 0xbf: 16403 GETBYTE (); 16404 switch (op[2] & 0x00) 16405 { 16406 case 0x00: 16407 goto op_semantics_125; 16408 break; 16409 } 16410 break; 16411 default: UNSUPPORTED(); break; 16412 } 16413 break; 16414 default: UNSUPPORTED(); break; 16415 } 16416 #line 1122 "rx-decode.opc" 16417 16418 return rx->n_bytes; 16419 } 16420