1 #line 1 "rx-decode.opc" 2 /* -*- c -*- */ 3 /* Copyright (C) 2012-2016 Free Software Foundation, Inc. 4 Contributed by Red Hat. 5 Written by DJ Delorie. 6 7 This file is part of the GNU opcodes library. 8 9 This library is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3, or (at your option) 12 any later version. 13 14 It is distributed in the hope that it will be useful, but WITHOUT 15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 16 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public 17 License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 22 MA 02110-1301, USA. */ 23 24 #include "sysdep.h" 25 #include <stdio.h> 26 #include <stdlib.h> 27 #include <string.h> 28 #include "ansidecl.h" 29 #include "opcode/rx.h" 30 31 #define RX_OPCODE_BIG_ENDIAN 0 32 33 typedef struct 34 { 35 RX_Opcode_Decoded * rx; 36 int (* getbyte)(void *); 37 void * ptr; 38 unsigned char * op; 39 } LocalData; 40 41 static int trace = 0; 42 43 #define BSIZE 0 44 #define WSIZE 1 45 #define LSIZE 2 46 47 /* These are for when the upper bits are "don't care" or "undefined". */ 48 static int bwl[] = 49 { 50 RX_Byte, 51 RX_Word, 52 RX_Long, 53 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */ 54 }; 55 56 static int sbwl[] = 57 { 58 RX_SByte, 59 RX_SWord, 60 RX_Long, 61 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */ 62 }; 63 64 static int ubw[] = 65 { 66 RX_UByte, 67 RX_UWord, 68 RX_Bad_Size,/* Bogus instructions can have a size field set to 2. */ 69 RX_Bad_Size /* Bogus instructions can have a size field set to 3. */ 70 }; 71 72 static int memex[] = 73 { 74 RX_SByte, 75 RX_SWord, 76 RX_Long, 77 RX_UWord 78 }; 79 80 #define ID(x) rx->id = RXO_##x 81 #define OP(n,t,r,a) (rx->op[n].type = t, \ 82 rx->op[n].reg = r, \ 83 rx->op[n].addend = a ) 84 #define OPs(n,t,r,a,s) (OP (n,t,r,a), \ 85 rx->op[n].size = s ) 86 87 /* This is for the BWL and BW bitfields. */ 88 static int SCALE[] = { 1, 2, 4, 0 }; 89 /* This is for the prefix size enum. */ 90 static int PSCALE[] = { 4, 1, 1, 1, 2, 2, 2, 3, 4 }; 91 92 static int flagmap[] = {0, 1, 2, 3, 0, 0, 0, 0, 93 16, 17, 0, 0, 0, 0, 0, 0 }; 94 95 static int dsp3map[] = { 8, 9, 10, 3, 4, 5, 6, 7 }; 96 97 /* 98 *C a constant (immediate) c 99 *R A register 100 *I Register indirect, no offset 101 *Is Register indirect, with offset 102 *D standard displacement: type (r,[r],dsp8,dsp16 code), register, BWL code 103 *P standard displacement: type (r,[r]), reg, assumes UByte 104 *Pm memex displacement: type (r,[r]), reg, memex code 105 *cc condition code. */ 106 107 #define DC(c) OP (0, RX_Operand_Immediate, 0, c) 108 #define DR(r) OP (0, RX_Operand_Register, r, 0) 109 #define DI(r,a) OP (0, RX_Operand_Indirect, r, a) 110 #define DIs(r,a,s) OP (0, RX_Operand_Indirect, r, (a) * SCALE[s]) 111 #define DD(t,r,s) rx_disp (0, t, r, bwl[s], ld); 112 #define DF(r) OP (0, RX_Operand_Flag, flagmap[r], 0) 113 114 #define SC(i) OP (1, RX_Operand_Immediate, 0, i) 115 #define SR(r) OP (1, RX_Operand_Register, r, 0) 116 #define SRR(r) OP (1, RX_Operand_TwoReg, r, 0) 117 #define SI(r,a) OP (1, RX_Operand_Indirect, r, a) 118 #define SIs(r,a,s) OP (1, RX_Operand_Indirect, r, (a) * SCALE[s]) 119 #define SD(t,r,s) rx_disp (1, t, r, bwl[s], ld); 120 #define SP(t,r) rx_disp (1, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 1); 121 #define SPm(t,r,m) rx_disp (1, t, r, memex[m], ld); rx->op[1].size = memex[m]; 122 #define Scc(cc) OP (1, RX_Operand_Condition, cc, 0) 123 124 #define S2C(i) OP (2, RX_Operand_Immediate, 0, i) 125 #define S2R(r) OP (2, RX_Operand_Register, r, 0) 126 #define S2I(r,a) OP (2, RX_Operand_Indirect, r, a) 127 #define S2Is(r,a,s) OP (2, RX_Operand_Indirect, r, (a) * SCALE[s]) 128 #define S2D(t,r,s) rx_disp (2, t, r, bwl[s], ld); 129 #define S2P(t,r) rx_disp (2, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 2); 130 #define S2Pm(t,r,m) rx_disp (2, t, r, memex[m], ld); rx->op[2].size = memex[m]; 131 #define S2cc(cc) OP (2, RX_Operand_Condition, cc, 0) 132 133 #define BWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = bwl[sz] 134 #define sBWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = sbwl[sz] 135 #define uBW(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = ubw[sz] 136 #define P(t, n) rx->op[n].size = (t!=3) ? RX_UByte : RX_Long; 137 138 #define F(f) store_flags(rx, f) 139 140 #define AU ATTRIBUTE_UNUSED 141 #define GETBYTE() (ld->op [ld->rx->n_bytes++] = ld->getbyte (ld->ptr)) 142 143 #define SYNTAX(x) rx->syntax = x 144 145 #define UNSUPPORTED() \ 146 rx->syntax = "*unknown*" 147 148 #define IMM(sf) immediate (sf, 0, ld) 149 #define IMMex(sf) immediate (sf, 1, ld) 150 151 static int 152 immediate (int sfield, int ex, LocalData * ld) 153 { 154 unsigned long i = 0, j; 155 156 switch (sfield) 157 { 158 #define B ((unsigned long) GETBYTE()) 159 case 0: 160 #if RX_OPCODE_BIG_ENDIAN 161 i = B; 162 if (ex && (i & 0x80)) 163 i -= 0x100; 164 i <<= 24; 165 i |= B << 16; 166 i |= B << 8; 167 i |= B; 168 #else 169 i = B; 170 i |= B << 8; 171 i |= B << 16; 172 j = B; 173 if (ex && (j & 0x80)) 174 j -= 0x100; 175 i |= j << 24; 176 #endif 177 break; 178 case 3: 179 #if RX_OPCODE_BIG_ENDIAN 180 i = B << 16; 181 i |= B << 8; 182 i |= B; 183 #else 184 i = B; 185 i |= B << 8; 186 i |= B << 16; 187 #endif 188 if (ex && (i & 0x800000)) 189 i -= 0x1000000; 190 break; 191 case 2: 192 #if RX_OPCODE_BIG_ENDIAN 193 i |= B << 8; 194 i |= B; 195 #else 196 i |= B; 197 i |= B << 8; 198 #endif 199 if (ex && (i & 0x8000)) 200 i -= 0x10000; 201 break; 202 case 1: 203 i |= B; 204 if (ex && (i & 0x80)) 205 i -= 0x100; 206 break; 207 default: 208 abort(); 209 } 210 return i; 211 } 212 213 static void 214 rx_disp (int n, int type, int reg, int size, LocalData * ld) 215 { 216 int disp; 217 218 ld->rx->op[n].reg = reg; 219 switch (type) 220 { 221 case 3: 222 ld->rx->op[n].type = RX_Operand_Register; 223 break; 224 case 0: 225 ld->rx->op[n].type = RX_Operand_Zero_Indirect; 226 ld->rx->op[n].addend = 0; 227 break; 228 case 1: 229 ld->rx->op[n].type = RX_Operand_Indirect; 230 disp = GETBYTE (); 231 ld->rx->op[n].addend = disp * PSCALE[size]; 232 break; 233 case 2: 234 ld->rx->op[n].type = RX_Operand_Indirect; 235 disp = GETBYTE (); 236 #if RX_OPCODE_BIG_ENDIAN 237 disp = disp * 256 + GETBYTE (); 238 #else 239 disp = disp + GETBYTE () * 256; 240 #endif 241 ld->rx->op[n].addend = disp * PSCALE[size]; 242 break; 243 default: 244 abort (); 245 } 246 } 247 248 #define xO 8 249 #define xS 4 250 #define xZ 2 251 #define xC 1 252 253 #define F_____ 254 #define F___ZC rx->flags_0 = rx->flags_s = xZ|xC; 255 #define F__SZ_ rx->flags_0 = rx->flags_s = xS|xZ; 256 #define F__SZC rx->flags_0 = rx->flags_s = xS|xZ|xC; 257 #define F_0SZC rx->flags_0 = xO|xS|xZ|xC; rx->flags_s = xS|xZ|xC; 258 #define F_O___ rx->flags_0 = rx->flags_s = xO; 259 #define F_OS__ rx->flags_0 = rx->flags_s = xO|xS; 260 #define F_OSZ_ rx->flags_0 = rx->flags_s = xO|xS|xZ; 261 #define F_OSZC rx->flags_0 = rx->flags_s = xO|xS|xZ|xC; 262 263 int 264 rx_decode_opcode (unsigned long pc AU, 265 RX_Opcode_Decoded * rx, 266 int (* getbyte)(void *), 267 void * ptr) 268 { 269 LocalData lds, * ld = &lds; 270 unsigned char op[20] = {0}; 271 272 lds.rx = rx; 273 lds.getbyte = getbyte; 274 lds.ptr = ptr; 275 lds.op = op; 276 277 memset (rx, 0, sizeof (*rx)); 278 BWL(LSIZE); 279 280 281 /*----------------------------------------------------------------------*/ 282 /* MOV */ 283 284 GETBYTE (); 285 switch (op[0] & 0xff) 286 { 287 case 0x00: 288 { 289 /** 0000 0000 brk */ 290 if (trace) 291 { 292 printf ("\033[33m%s\033[0m %02x\n", 293 "/** 0000 0000 brk */", 294 op[0]); 295 } 296 SYNTAX("brk"); 297 #line 1025 "rx-decode.opc" 298 ID(brk); 299 300 } 301 break; 302 case 0x01: 303 { 304 /** 0000 0001 dbt */ 305 if (trace) 306 { 307 printf ("\033[33m%s\033[0m %02x\n", 308 "/** 0000 0001 dbt */", 309 op[0]); 310 } 311 SYNTAX("dbt"); 312 #line 1028 "rx-decode.opc" 313 ID(dbt); 314 315 } 316 break; 317 case 0x02: 318 { 319 /** 0000 0010 rts */ 320 if (trace) 321 { 322 printf ("\033[33m%s\033[0m %02x\n", 323 "/** 0000 0010 rts */", 324 op[0]); 325 } 326 SYNTAX("rts"); 327 #line 806 "rx-decode.opc" 328 ID(rts); 329 330 /*----------------------------------------------------------------------*/ 331 /* NOP */ 332 333 } 334 break; 335 case 0x03: 336 { 337 /** 0000 0011 nop */ 338 if (trace) 339 { 340 printf ("\033[33m%s\033[0m %02x\n", 341 "/** 0000 0011 nop */", 342 op[0]); 343 } 344 SYNTAX("nop"); 345 #line 812 "rx-decode.opc" 346 ID(nop); 347 348 /*----------------------------------------------------------------------*/ 349 /* STRING FUNCTIONS */ 350 351 } 352 break; 353 case 0x04: 354 { 355 /** 0000 0100 bra.a %a0 */ 356 if (trace) 357 { 358 printf ("\033[33m%s\033[0m %02x\n", 359 "/** 0000 0100 bra.a %a0 */", 360 op[0]); 361 } 362 SYNTAX("bra.a %a0"); 363 #line 784 "rx-decode.opc" 364 ID(branch); DC(pc + IMMex(3)); 365 366 } 367 break; 368 case 0x05: 369 { 370 /** 0000 0101 bsr.a %a0 */ 371 if (trace) 372 { 373 printf ("\033[33m%s\033[0m %02x\n", 374 "/** 0000 0101 bsr.a %a0 */", 375 op[0]); 376 } 377 SYNTAX("bsr.a %a0"); 378 #line 800 "rx-decode.opc" 379 ID(jsr); DC(pc + IMMex(3)); 380 381 } 382 break; 383 case 0x06: 384 GETBYTE (); 385 switch (op[1] & 0xff) 386 { 387 case 0x00: 388 GETBYTE (); 389 switch (op[2] & 0x00) 390 { 391 case 0x00: 392 op_semantics_1: 393 { 394 /** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */ 395 #line 542 "rx-decode.opc" 396 int mx AU = (op[1] >> 6) & 0x03; 397 #line 542 "rx-decode.opc" 398 int ss AU = op[1] & 0x03; 399 #line 542 "rx-decode.opc" 400 int rsrc AU = (op[2] >> 4) & 0x0f; 401 #line 542 "rx-decode.opc" 402 int rdst AU = op[2] & 0x0f; 403 if (trace) 404 { 405 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 406 "/** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */", 407 op[0], op[1], op[2]); 408 printf (" mx = 0x%x,", mx); 409 printf (" ss = 0x%x,", ss); 410 printf (" rsrc = 0x%x,", rsrc); 411 printf (" rdst = 0x%x\n", rdst); 412 } 413 SYNTAX("sub %2%S2, %1"); 414 #line 542 "rx-decode.opc" 415 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F_OSZC; 416 417 } 418 break; 419 } 420 break; 421 case 0x01: 422 GETBYTE (); 423 switch (op[2] & 0x00) 424 { 425 case 0x00: 426 goto op_semantics_1; 427 break; 428 } 429 break; 430 case 0x02: 431 GETBYTE (); 432 switch (op[2] & 0x00) 433 { 434 case 0x00: 435 goto op_semantics_1; 436 break; 437 } 438 break; 439 case 0x03: 440 GETBYTE (); 441 switch (op[2] & 0x00) 442 { 443 case 0x00: 444 goto op_semantics_1; 445 break; 446 } 447 break; 448 case 0x04: 449 GETBYTE (); 450 switch (op[2] & 0x00) 451 { 452 case 0x00: 453 op_semantics_2: 454 { 455 /** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */ 456 #line 530 "rx-decode.opc" 457 int mx AU = (op[1] >> 6) & 0x03; 458 #line 530 "rx-decode.opc" 459 int ss AU = op[1] & 0x03; 460 #line 530 "rx-decode.opc" 461 int rsrc AU = (op[2] >> 4) & 0x0f; 462 #line 530 "rx-decode.opc" 463 int rdst AU = op[2] & 0x0f; 464 if (trace) 465 { 466 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 467 "/** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */", 468 op[0], op[1], op[2]); 469 printf (" mx = 0x%x,", mx); 470 printf (" ss = 0x%x,", ss); 471 printf (" rsrc = 0x%x,", rsrc); 472 printf (" rdst = 0x%x\n", rdst); 473 } 474 SYNTAX("cmp %2%S2, %1"); 475 #line 530 "rx-decode.opc" 476 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F_OSZC; 477 478 /*----------------------------------------------------------------------*/ 479 /* SUB */ 480 481 } 482 break; 483 } 484 break; 485 case 0x05: 486 GETBYTE (); 487 switch (op[2] & 0x00) 488 { 489 case 0x00: 490 goto op_semantics_2; 491 break; 492 } 493 break; 494 case 0x06: 495 GETBYTE (); 496 switch (op[2] & 0x00) 497 { 498 case 0x00: 499 goto op_semantics_2; 500 break; 501 } 502 break; 503 case 0x07: 504 GETBYTE (); 505 switch (op[2] & 0x00) 506 { 507 case 0x00: 508 goto op_semantics_2; 509 break; 510 } 511 break; 512 case 0x08: 513 GETBYTE (); 514 switch (op[2] & 0x00) 515 { 516 case 0x00: 517 op_semantics_3: 518 { 519 /** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */ 520 #line 506 "rx-decode.opc" 521 int mx AU = (op[1] >> 6) & 0x03; 522 #line 506 "rx-decode.opc" 523 int ss AU = op[1] & 0x03; 524 #line 506 "rx-decode.opc" 525 int rsrc AU = (op[2] >> 4) & 0x0f; 526 #line 506 "rx-decode.opc" 527 int rdst AU = op[2] & 0x0f; 528 if (trace) 529 { 530 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 531 "/** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */", 532 op[0], op[1], op[2]); 533 printf (" mx = 0x%x,", mx); 534 printf (" ss = 0x%x,", ss); 535 printf (" rsrc = 0x%x,", rsrc); 536 printf (" rdst = 0x%x\n", rdst); 537 } 538 SYNTAX("add %1%S1, %0"); 539 #line 506 "rx-decode.opc" 540 ID(add); SPm(ss, rsrc, mx); DR(rdst); F_OSZC; 541 542 } 543 break; 544 } 545 break; 546 case 0x09: 547 GETBYTE (); 548 switch (op[2] & 0x00) 549 { 550 case 0x00: 551 goto op_semantics_3; 552 break; 553 } 554 break; 555 case 0x0a: 556 GETBYTE (); 557 switch (op[2] & 0x00) 558 { 559 case 0x00: 560 goto op_semantics_3; 561 break; 562 } 563 break; 564 case 0x0b: 565 GETBYTE (); 566 switch (op[2] & 0x00) 567 { 568 case 0x00: 569 goto op_semantics_3; 570 break; 571 } 572 break; 573 case 0x0c: 574 GETBYTE (); 575 switch (op[2] & 0x00) 576 { 577 case 0x00: 578 op_semantics_4: 579 { 580 /** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */ 581 #line 649 "rx-decode.opc" 582 int mx AU = (op[1] >> 6) & 0x03; 583 #line 649 "rx-decode.opc" 584 int ss AU = op[1] & 0x03; 585 #line 649 "rx-decode.opc" 586 int rsrc AU = (op[2] >> 4) & 0x0f; 587 #line 649 "rx-decode.opc" 588 int rdst AU = op[2] & 0x0f; 589 if (trace) 590 { 591 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 592 "/** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */", 593 op[0], op[1], op[2]); 594 printf (" mx = 0x%x,", mx); 595 printf (" ss = 0x%x,", ss); 596 printf (" rsrc = 0x%x,", rsrc); 597 printf (" rdst = 0x%x\n", rdst); 598 } 599 SYNTAX("mul %1%S1, %0"); 600 #line 649 "rx-decode.opc" 601 ID(mul); SPm(ss, rsrc, mx); DR(rdst); F_____; 602 603 } 604 break; 605 } 606 break; 607 case 0x0d: 608 GETBYTE (); 609 switch (op[2] & 0x00) 610 { 611 case 0x00: 612 goto op_semantics_4; 613 break; 614 } 615 break; 616 case 0x0e: 617 GETBYTE (); 618 switch (op[2] & 0x00) 619 { 620 case 0x00: 621 goto op_semantics_4; 622 break; 623 } 624 break; 625 case 0x0f: 626 GETBYTE (); 627 switch (op[2] & 0x00) 628 { 629 case 0x00: 630 goto op_semantics_4; 631 break; 632 } 633 break; 634 case 0x10: 635 GETBYTE (); 636 switch (op[2] & 0x00) 637 { 638 case 0x00: 639 op_semantics_5: 640 { 641 /** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */ 642 #line 419 "rx-decode.opc" 643 int mx AU = (op[1] >> 6) & 0x03; 644 #line 419 "rx-decode.opc" 645 int ss AU = op[1] & 0x03; 646 #line 419 "rx-decode.opc" 647 int rsrc AU = (op[2] >> 4) & 0x0f; 648 #line 419 "rx-decode.opc" 649 int rdst AU = op[2] & 0x0f; 650 if (trace) 651 { 652 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 653 "/** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */", 654 op[0], op[1], op[2]); 655 printf (" mx = 0x%x,", mx); 656 printf (" ss = 0x%x,", ss); 657 printf (" rsrc = 0x%x,", rsrc); 658 printf (" rdst = 0x%x\n", rdst); 659 } 660 SYNTAX("and %1%S1, %0"); 661 #line 419 "rx-decode.opc" 662 ID(and); SPm(ss, rsrc, mx); DR(rdst); F__SZ_; 663 664 } 665 break; 666 } 667 break; 668 case 0x11: 669 GETBYTE (); 670 switch (op[2] & 0x00) 671 { 672 case 0x00: 673 goto op_semantics_5; 674 break; 675 } 676 break; 677 case 0x12: 678 GETBYTE (); 679 switch (op[2] & 0x00) 680 { 681 case 0x00: 682 goto op_semantics_5; 683 break; 684 } 685 break; 686 case 0x13: 687 GETBYTE (); 688 switch (op[2] & 0x00) 689 { 690 case 0x00: 691 goto op_semantics_5; 692 break; 693 } 694 break; 695 case 0x14: 696 GETBYTE (); 697 switch (op[2] & 0x00) 698 { 699 case 0x00: 700 op_semantics_6: 701 { 702 /** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */ 703 #line 437 "rx-decode.opc" 704 int mx AU = (op[1] >> 6) & 0x03; 705 #line 437 "rx-decode.opc" 706 int ss AU = op[1] & 0x03; 707 #line 437 "rx-decode.opc" 708 int rsrc AU = (op[2] >> 4) & 0x0f; 709 #line 437 "rx-decode.opc" 710 int rdst AU = op[2] & 0x0f; 711 if (trace) 712 { 713 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 714 "/** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */", 715 op[0], op[1], op[2]); 716 printf (" mx = 0x%x,", mx); 717 printf (" ss = 0x%x,", ss); 718 printf (" rsrc = 0x%x,", rsrc); 719 printf (" rdst = 0x%x\n", rdst); 720 } 721 SYNTAX("or %1%S1, %0"); 722 #line 437 "rx-decode.opc" 723 ID(or); SPm(ss, rsrc, mx); DR(rdst); F__SZ_; 724 725 } 726 break; 727 } 728 break; 729 case 0x15: 730 GETBYTE (); 731 switch (op[2] & 0x00) 732 { 733 case 0x00: 734 goto op_semantics_6; 735 break; 736 } 737 break; 738 case 0x16: 739 GETBYTE (); 740 switch (op[2] & 0x00) 741 { 742 case 0x00: 743 goto op_semantics_6; 744 break; 745 } 746 break; 747 case 0x17: 748 GETBYTE (); 749 switch (op[2] & 0x00) 750 { 751 case 0x00: 752 goto op_semantics_6; 753 break; 754 } 755 break; 756 case 0x20: 757 GETBYTE (); 758 switch (op[2] & 0xff) 759 { 760 case 0x00: 761 GETBYTE (); 762 switch (op[3] & 0x00) 763 { 764 case 0x00: 765 op_semantics_7: 766 { 767 /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */ 768 #line 555 "rx-decode.opc" 769 int mx AU = (op[1] >> 6) & 0x03; 770 #line 555 "rx-decode.opc" 771 int sp AU = op[1] & 0x03; 772 #line 555 "rx-decode.opc" 773 int rsrc AU = (op[3] >> 4) & 0x0f; 774 #line 555 "rx-decode.opc" 775 int rdst AU = op[3] & 0x0f; 776 if (trace) 777 { 778 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 779 "/** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */", 780 op[0], op[1], op[2], op[3]); 781 printf (" mx = 0x%x,", mx); 782 printf (" sp = 0x%x,", sp); 783 printf (" rsrc = 0x%x,", rsrc); 784 printf (" rdst = 0x%x\n", rdst); 785 } 786 SYNTAX("sbb %1%S1, %0"); 787 #line 555 "rx-decode.opc" 788 ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F_OSZC; 789 790 /*----------------------------------------------------------------------*/ 791 /* ABS */ 792 793 } 794 break; 795 } 796 break; 797 case 0x04: 798 GETBYTE (); 799 switch (op[3] & 0x00) 800 { 801 case 0x00: 802 op_semantics_8: 803 { 804 /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */ 805 #line 594 "rx-decode.opc" 806 int mx AU = (op[1] >> 6) & 0x03; 807 #line 594 "rx-decode.opc" 808 int ss AU = op[1] & 0x03; 809 #line 594 "rx-decode.opc" 810 int rsrc AU = (op[3] >> 4) & 0x0f; 811 #line 594 "rx-decode.opc" 812 int rdst AU = op[3] & 0x0f; 813 if (trace) 814 { 815 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 816 "/** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */", 817 op[0], op[1], op[2], op[3]); 818 printf (" mx = 0x%x,", mx); 819 printf (" ss = 0x%x,", ss); 820 printf (" rsrc = 0x%x,", rsrc); 821 printf (" rdst = 0x%x\n", rdst); 822 } 823 SYNTAX("max %1%S1, %0"); 824 #line 594 "rx-decode.opc" 825 ID(max); SPm(ss, rsrc, mx); DR(rdst); 826 827 /*----------------------------------------------------------------------*/ 828 /* MIN */ 829 830 } 831 break; 832 } 833 break; 834 case 0x05: 835 GETBYTE (); 836 switch (op[3] & 0x00) 837 { 838 case 0x00: 839 op_semantics_9: 840 { 841 /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */ 842 #line 606 "rx-decode.opc" 843 int mx AU = (op[1] >> 6) & 0x03; 844 #line 606 "rx-decode.opc" 845 int ss AU = op[1] & 0x03; 846 #line 606 "rx-decode.opc" 847 int rsrc AU = (op[3] >> 4) & 0x0f; 848 #line 606 "rx-decode.opc" 849 int rdst AU = op[3] & 0x0f; 850 if (trace) 851 { 852 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 853 "/** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */", 854 op[0], op[1], op[2], op[3]); 855 printf (" mx = 0x%x,", mx); 856 printf (" ss = 0x%x,", ss); 857 printf (" rsrc = 0x%x,", rsrc); 858 printf (" rdst = 0x%x\n", rdst); 859 } 860 SYNTAX("min %1%S1, %0"); 861 #line 606 "rx-decode.opc" 862 ID(min); SPm(ss, rsrc, mx); DR(rdst); 863 864 /*----------------------------------------------------------------------*/ 865 /* MUL */ 866 867 } 868 break; 869 } 870 break; 871 case 0x06: 872 GETBYTE (); 873 switch (op[3] & 0x00) 874 { 875 case 0x00: 876 op_semantics_10: 877 { 878 /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */ 879 #line 664 "rx-decode.opc" 880 int mx AU = (op[1] >> 6) & 0x03; 881 #line 664 "rx-decode.opc" 882 int ss AU = op[1] & 0x03; 883 #line 664 "rx-decode.opc" 884 int rsrc AU = (op[3] >> 4) & 0x0f; 885 #line 664 "rx-decode.opc" 886 int rdst AU = op[3] & 0x0f; 887 if (trace) 888 { 889 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 890 "/** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */", 891 op[0], op[1], op[2], op[3]); 892 printf (" mx = 0x%x,", mx); 893 printf (" ss = 0x%x,", ss); 894 printf (" rsrc = 0x%x,", rsrc); 895 printf (" rdst = 0x%x\n", rdst); 896 } 897 SYNTAX("emul %1%S1, %0"); 898 #line 664 "rx-decode.opc" 899 ID(emul); SPm(ss, rsrc, mx); DR(rdst); 900 901 /*----------------------------------------------------------------------*/ 902 /* EMULU */ 903 904 } 905 break; 906 } 907 break; 908 case 0x07: 909 GETBYTE (); 910 switch (op[3] & 0x00) 911 { 912 case 0x00: 913 op_semantics_11: 914 { 915 /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */ 916 #line 676 "rx-decode.opc" 917 int mx AU = (op[1] >> 6) & 0x03; 918 #line 676 "rx-decode.opc" 919 int ss AU = op[1] & 0x03; 920 #line 676 "rx-decode.opc" 921 int rsrc AU = (op[3] >> 4) & 0x0f; 922 #line 676 "rx-decode.opc" 923 int rdst AU = op[3] & 0x0f; 924 if (trace) 925 { 926 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 927 "/** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */", 928 op[0], op[1], op[2], op[3]); 929 printf (" mx = 0x%x,", mx); 930 printf (" ss = 0x%x,", ss); 931 printf (" rsrc = 0x%x,", rsrc); 932 printf (" rdst = 0x%x\n", rdst); 933 } 934 SYNTAX("emulu %1%S1, %0"); 935 #line 676 "rx-decode.opc" 936 ID(emulu); SPm(ss, rsrc, mx); DR(rdst); 937 938 /*----------------------------------------------------------------------*/ 939 /* DIV */ 940 941 } 942 break; 943 } 944 break; 945 case 0x08: 946 GETBYTE (); 947 switch (op[3] & 0x00) 948 { 949 case 0x00: 950 op_semantics_12: 951 { 952 /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */ 953 #line 688 "rx-decode.opc" 954 int mx AU = (op[1] >> 6) & 0x03; 955 #line 688 "rx-decode.opc" 956 int ss AU = op[1] & 0x03; 957 #line 688 "rx-decode.opc" 958 int rsrc AU = (op[3] >> 4) & 0x0f; 959 #line 688 "rx-decode.opc" 960 int rdst AU = op[3] & 0x0f; 961 if (trace) 962 { 963 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 964 "/** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */", 965 op[0], op[1], op[2], op[3]); 966 printf (" mx = 0x%x,", mx); 967 printf (" ss = 0x%x,", ss); 968 printf (" rsrc = 0x%x,", rsrc); 969 printf (" rdst = 0x%x\n", rdst); 970 } 971 SYNTAX("div %1%S1, %0"); 972 #line 688 "rx-decode.opc" 973 ID(div); SPm(ss, rsrc, mx); DR(rdst); F_O___; 974 975 /*----------------------------------------------------------------------*/ 976 /* DIVU */ 977 978 } 979 break; 980 } 981 break; 982 case 0x09: 983 GETBYTE (); 984 switch (op[3] & 0x00) 985 { 986 case 0x00: 987 op_semantics_13: 988 { 989 /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */ 990 #line 700 "rx-decode.opc" 991 int mx AU = (op[1] >> 6) & 0x03; 992 #line 700 "rx-decode.opc" 993 int ss AU = op[1] & 0x03; 994 #line 700 "rx-decode.opc" 995 int rsrc AU = (op[3] >> 4) & 0x0f; 996 #line 700 "rx-decode.opc" 997 int rdst AU = op[3] & 0x0f; 998 if (trace) 999 { 1000 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 1001 "/** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */", 1002 op[0], op[1], op[2], op[3]); 1003 printf (" mx = 0x%x,", mx); 1004 printf (" ss = 0x%x,", ss); 1005 printf (" rsrc = 0x%x,", rsrc); 1006 printf (" rdst = 0x%x\n", rdst); 1007 } 1008 SYNTAX("divu %1%S1, %0"); 1009 #line 700 "rx-decode.opc" 1010 ID(divu); SPm(ss, rsrc, mx); DR(rdst); F_O___; 1011 1012 /*----------------------------------------------------------------------*/ 1013 /* SHIFT */ 1014 1015 } 1016 break; 1017 } 1018 break; 1019 case 0x0c: 1020 GETBYTE (); 1021 switch (op[3] & 0x00) 1022 { 1023 case 0x00: 1024 op_semantics_14: 1025 { 1026 /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */ 1027 #line 473 "rx-decode.opc" 1028 int mx AU = (op[1] >> 6) & 0x03; 1029 #line 473 "rx-decode.opc" 1030 int ss AU = op[1] & 0x03; 1031 #line 473 "rx-decode.opc" 1032 int rsrc AU = (op[3] >> 4) & 0x0f; 1033 #line 473 "rx-decode.opc" 1034 int rdst AU = op[3] & 0x0f; 1035 if (trace) 1036 { 1037 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 1038 "/** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */", 1039 op[0], op[1], op[2], op[3]); 1040 printf (" mx = 0x%x,", mx); 1041 printf (" ss = 0x%x,", ss); 1042 printf (" rsrc = 0x%x,", rsrc); 1043 printf (" rdst = 0x%x\n", rdst); 1044 } 1045 SYNTAX("tst %1%S1, %2"); 1046 #line 473 "rx-decode.opc" 1047 ID(and); SPm(ss, rsrc, mx); S2R(rdst); F__SZ_; 1048 1049 /*----------------------------------------------------------------------*/ 1050 /* NEG */ 1051 1052 } 1053 break; 1054 } 1055 break; 1056 case 0x0d: 1057 GETBYTE (); 1058 switch (op[3] & 0x00) 1059 { 1060 case 0x00: 1061 op_semantics_15: 1062 { 1063 /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */ 1064 #line 452 "rx-decode.opc" 1065 int mx AU = (op[1] >> 6) & 0x03; 1066 #line 452 "rx-decode.opc" 1067 int ss AU = op[1] & 0x03; 1068 #line 452 "rx-decode.opc" 1069 int rsrc AU = (op[3] >> 4) & 0x0f; 1070 #line 452 "rx-decode.opc" 1071 int rdst AU = op[3] & 0x0f; 1072 if (trace) 1073 { 1074 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 1075 "/** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */", 1076 op[0], op[1], op[2], op[3]); 1077 printf (" mx = 0x%x,", mx); 1078 printf (" ss = 0x%x,", ss); 1079 printf (" rsrc = 0x%x,", rsrc); 1080 printf (" rdst = 0x%x\n", rdst); 1081 } 1082 SYNTAX("xor %1%S1, %0"); 1083 #line 452 "rx-decode.opc" 1084 ID(xor); SPm(ss, rsrc, mx); DR(rdst); F__SZ_; 1085 1086 /*----------------------------------------------------------------------*/ 1087 /* NOT */ 1088 1089 } 1090 break; 1091 } 1092 break; 1093 case 0x10: 1094 GETBYTE (); 1095 switch (op[3] & 0x00) 1096 { 1097 case 0x00: 1098 op_semantics_16: 1099 { 1100 /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */ 1101 #line 386 "rx-decode.opc" 1102 int mx AU = (op[1] >> 6) & 0x03; 1103 #line 386 "rx-decode.opc" 1104 int ss AU = op[1] & 0x03; 1105 #line 386 "rx-decode.opc" 1106 int rsrc AU = (op[3] >> 4) & 0x0f; 1107 #line 386 "rx-decode.opc" 1108 int rdst AU = op[3] & 0x0f; 1109 if (trace) 1110 { 1111 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 1112 "/** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */", 1113 op[0], op[1], op[2], op[3]); 1114 printf (" mx = 0x%x,", mx); 1115 printf (" ss = 0x%x,", ss); 1116 printf (" rsrc = 0x%x,", rsrc); 1117 printf (" rdst = 0x%x\n", rdst); 1118 } 1119 SYNTAX("xchg %1%S1, %0"); 1120 #line 386 "rx-decode.opc" 1121 ID(xchg); DR(rdst); SPm(ss, rsrc, mx); 1122 1123 /*----------------------------------------------------------------------*/ 1124 /* STZ/STNZ */ 1125 1126 } 1127 break; 1128 } 1129 break; 1130 case 0x11: 1131 GETBYTE (); 1132 switch (op[3] & 0x00) 1133 { 1134 case 0x00: 1135 op_semantics_17: 1136 { 1137 /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */ 1138 #line 929 "rx-decode.opc" 1139 int mx AU = (op[1] >> 6) & 0x03; 1140 #line 929 "rx-decode.opc" 1141 int sd AU = op[1] & 0x03; 1142 #line 929 "rx-decode.opc" 1143 int rsrc AU = (op[3] >> 4) & 0x0f; 1144 #line 929 "rx-decode.opc" 1145 int rdst AU = op[3] & 0x0f; 1146 if (trace) 1147 { 1148 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 1149 "/** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */", 1150 op[0], op[1], op[2], op[3]); 1151 printf (" mx = 0x%x,", mx); 1152 printf (" sd = 0x%x,", sd); 1153 printf (" rsrc = 0x%x,", rsrc); 1154 printf (" rdst = 0x%x\n", rdst); 1155 } 1156 SYNTAX("itof %1%S1, %0"); 1157 #line 929 "rx-decode.opc" 1158 ID(itof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_; 1159 1160 /*----------------------------------------------------------------------*/ 1161 /* BIT OPS */ 1162 1163 } 1164 break; 1165 } 1166 break; 1167 case 0x15: 1168 GETBYTE (); 1169 switch (op[3] & 0x00) 1170 { 1171 case 0x00: 1172 op_semantics_18: 1173 { 1174 /** 0000 0110 mx10 00sd 0001 0101 rsrc rdst utof %1%S1, %0 */ 1175 #line 1115 "rx-decode.opc" 1176 int mx AU = (op[1] >> 6) & 0x03; 1177 #line 1115 "rx-decode.opc" 1178 int sd AU = op[1] & 0x03; 1179 #line 1115 "rx-decode.opc" 1180 int rsrc AU = (op[3] >> 4) & 0x0f; 1181 #line 1115 "rx-decode.opc" 1182 int rdst AU = op[3] & 0x0f; 1183 if (trace) 1184 { 1185 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 1186 "/** 0000 0110 mx10 00sd 0001 0101 rsrc rdst utof %1%S1, %0 */", 1187 op[0], op[1], op[2], op[3]); 1188 printf (" mx = 0x%x,", mx); 1189 printf (" sd = 0x%x,", sd); 1190 printf (" rsrc = 0x%x,", rsrc); 1191 printf (" rdst = 0x%x\n", rdst); 1192 } 1193 SYNTAX("utof %1%S1, %0"); 1194 #line 1115 "rx-decode.opc" 1195 ID(utof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_; 1196 1197 } 1198 break; 1199 } 1200 break; 1201 default: UNSUPPORTED(); break; 1202 } 1203 break; 1204 case 0x21: 1205 GETBYTE (); 1206 switch (op[2] & 0xff) 1207 { 1208 case 0x00: 1209 GETBYTE (); 1210 switch (op[3] & 0x00) 1211 { 1212 case 0x00: 1213 goto op_semantics_7; 1214 break; 1215 } 1216 break; 1217 case 0x04: 1218 GETBYTE (); 1219 switch (op[3] & 0x00) 1220 { 1221 case 0x00: 1222 goto op_semantics_8; 1223 break; 1224 } 1225 break; 1226 case 0x05: 1227 GETBYTE (); 1228 switch (op[3] & 0x00) 1229 { 1230 case 0x00: 1231 goto op_semantics_9; 1232 break; 1233 } 1234 break; 1235 case 0x06: 1236 GETBYTE (); 1237 switch (op[3] & 0x00) 1238 { 1239 case 0x00: 1240 goto op_semantics_10; 1241 break; 1242 } 1243 break; 1244 case 0x07: 1245 GETBYTE (); 1246 switch (op[3] & 0x00) 1247 { 1248 case 0x00: 1249 goto op_semantics_11; 1250 break; 1251 } 1252 break; 1253 case 0x08: 1254 GETBYTE (); 1255 switch (op[3] & 0x00) 1256 { 1257 case 0x00: 1258 goto op_semantics_12; 1259 break; 1260 } 1261 break; 1262 case 0x09: 1263 GETBYTE (); 1264 switch (op[3] & 0x00) 1265 { 1266 case 0x00: 1267 goto op_semantics_13; 1268 break; 1269 } 1270 break; 1271 case 0x0c: 1272 GETBYTE (); 1273 switch (op[3] & 0x00) 1274 { 1275 case 0x00: 1276 goto op_semantics_14; 1277 break; 1278 } 1279 break; 1280 case 0x0d: 1281 GETBYTE (); 1282 switch (op[3] & 0x00) 1283 { 1284 case 0x00: 1285 goto op_semantics_15; 1286 break; 1287 } 1288 break; 1289 case 0x10: 1290 GETBYTE (); 1291 switch (op[3] & 0x00) 1292 { 1293 case 0x00: 1294 goto op_semantics_16; 1295 break; 1296 } 1297 break; 1298 case 0x11: 1299 GETBYTE (); 1300 switch (op[3] & 0x00) 1301 { 1302 case 0x00: 1303 goto op_semantics_17; 1304 break; 1305 } 1306 break; 1307 case 0x15: 1308 GETBYTE (); 1309 switch (op[3] & 0x00) 1310 { 1311 case 0x00: 1312 goto op_semantics_18; 1313 break; 1314 } 1315 break; 1316 default: UNSUPPORTED(); break; 1317 } 1318 break; 1319 case 0x22: 1320 GETBYTE (); 1321 switch (op[2] & 0xff) 1322 { 1323 case 0x00: 1324 GETBYTE (); 1325 switch (op[3] & 0x00) 1326 { 1327 case 0x00: 1328 goto op_semantics_7; 1329 break; 1330 } 1331 break; 1332 case 0x04: 1333 GETBYTE (); 1334 switch (op[3] & 0x00) 1335 { 1336 case 0x00: 1337 goto op_semantics_8; 1338 break; 1339 } 1340 break; 1341 case 0x05: 1342 GETBYTE (); 1343 switch (op[3] & 0x00) 1344 { 1345 case 0x00: 1346 goto op_semantics_9; 1347 break; 1348 } 1349 break; 1350 case 0x06: 1351 GETBYTE (); 1352 switch (op[3] & 0x00) 1353 { 1354 case 0x00: 1355 goto op_semantics_10; 1356 break; 1357 } 1358 break; 1359 case 0x07: 1360 GETBYTE (); 1361 switch (op[3] & 0x00) 1362 { 1363 case 0x00: 1364 goto op_semantics_11; 1365 break; 1366 } 1367 break; 1368 case 0x08: 1369 GETBYTE (); 1370 switch (op[3] & 0x00) 1371 { 1372 case 0x00: 1373 goto op_semantics_12; 1374 break; 1375 } 1376 break; 1377 case 0x09: 1378 GETBYTE (); 1379 switch (op[3] & 0x00) 1380 { 1381 case 0x00: 1382 goto op_semantics_13; 1383 break; 1384 } 1385 break; 1386 case 0x0c: 1387 GETBYTE (); 1388 switch (op[3] & 0x00) 1389 { 1390 case 0x00: 1391 goto op_semantics_14; 1392 break; 1393 } 1394 break; 1395 case 0x0d: 1396 GETBYTE (); 1397 switch (op[3] & 0x00) 1398 { 1399 case 0x00: 1400 goto op_semantics_15; 1401 break; 1402 } 1403 break; 1404 case 0x10: 1405 GETBYTE (); 1406 switch (op[3] & 0x00) 1407 { 1408 case 0x00: 1409 goto op_semantics_16; 1410 break; 1411 } 1412 break; 1413 case 0x11: 1414 GETBYTE (); 1415 switch (op[3] & 0x00) 1416 { 1417 case 0x00: 1418 goto op_semantics_17; 1419 break; 1420 } 1421 break; 1422 case 0x15: 1423 GETBYTE (); 1424 switch (op[3] & 0x00) 1425 { 1426 case 0x00: 1427 goto op_semantics_18; 1428 break; 1429 } 1430 break; 1431 default: UNSUPPORTED(); break; 1432 } 1433 break; 1434 case 0x23: 1435 GETBYTE (); 1436 switch (op[2] & 0xff) 1437 { 1438 case 0x00: 1439 GETBYTE (); 1440 switch (op[3] & 0x00) 1441 { 1442 case 0x00: 1443 goto op_semantics_7; 1444 break; 1445 } 1446 break; 1447 case 0x04: 1448 GETBYTE (); 1449 switch (op[3] & 0x00) 1450 { 1451 case 0x00: 1452 goto op_semantics_8; 1453 break; 1454 } 1455 break; 1456 case 0x05: 1457 GETBYTE (); 1458 switch (op[3] & 0x00) 1459 { 1460 case 0x00: 1461 goto op_semantics_9; 1462 break; 1463 } 1464 break; 1465 case 0x06: 1466 GETBYTE (); 1467 switch (op[3] & 0x00) 1468 { 1469 case 0x00: 1470 goto op_semantics_10; 1471 break; 1472 } 1473 break; 1474 case 0x07: 1475 GETBYTE (); 1476 switch (op[3] & 0x00) 1477 { 1478 case 0x00: 1479 goto op_semantics_11; 1480 break; 1481 } 1482 break; 1483 case 0x08: 1484 GETBYTE (); 1485 switch (op[3] & 0x00) 1486 { 1487 case 0x00: 1488 goto op_semantics_12; 1489 break; 1490 } 1491 break; 1492 case 0x09: 1493 GETBYTE (); 1494 switch (op[3] & 0x00) 1495 { 1496 case 0x00: 1497 goto op_semantics_13; 1498 break; 1499 } 1500 break; 1501 case 0x0c: 1502 GETBYTE (); 1503 switch (op[3] & 0x00) 1504 { 1505 case 0x00: 1506 goto op_semantics_14; 1507 break; 1508 } 1509 break; 1510 case 0x0d: 1511 GETBYTE (); 1512 switch (op[3] & 0x00) 1513 { 1514 case 0x00: 1515 goto op_semantics_15; 1516 break; 1517 } 1518 break; 1519 case 0x10: 1520 GETBYTE (); 1521 switch (op[3] & 0x00) 1522 { 1523 case 0x00: 1524 goto op_semantics_16; 1525 break; 1526 } 1527 break; 1528 case 0x11: 1529 GETBYTE (); 1530 switch (op[3] & 0x00) 1531 { 1532 case 0x00: 1533 goto op_semantics_17; 1534 break; 1535 } 1536 break; 1537 case 0x15: 1538 GETBYTE (); 1539 switch (op[3] & 0x00) 1540 { 1541 case 0x00: 1542 goto op_semantics_18; 1543 break; 1544 } 1545 break; 1546 default: UNSUPPORTED(); break; 1547 } 1548 break; 1549 case 0x40: 1550 GETBYTE (); 1551 switch (op[2] & 0x00) 1552 { 1553 case 0x00: 1554 goto op_semantics_1; 1555 break; 1556 } 1557 break; 1558 case 0x41: 1559 GETBYTE (); 1560 switch (op[2] & 0x00) 1561 { 1562 case 0x00: 1563 goto op_semantics_1; 1564 break; 1565 } 1566 break; 1567 case 0x42: 1568 GETBYTE (); 1569 switch (op[2] & 0x00) 1570 { 1571 case 0x00: 1572 goto op_semantics_1; 1573 break; 1574 } 1575 break; 1576 case 0x43: 1577 GETBYTE (); 1578 switch (op[2] & 0x00) 1579 { 1580 case 0x00: 1581 goto op_semantics_1; 1582 break; 1583 } 1584 break; 1585 case 0x44: 1586 GETBYTE (); 1587 switch (op[2] & 0x00) 1588 { 1589 case 0x00: 1590 goto op_semantics_2; 1591 break; 1592 } 1593 break; 1594 case 0x45: 1595 GETBYTE (); 1596 switch (op[2] & 0x00) 1597 { 1598 case 0x00: 1599 goto op_semantics_2; 1600 break; 1601 } 1602 break; 1603 case 0x46: 1604 GETBYTE (); 1605 switch (op[2] & 0x00) 1606 { 1607 case 0x00: 1608 goto op_semantics_2; 1609 break; 1610 } 1611 break; 1612 case 0x47: 1613 GETBYTE (); 1614 switch (op[2] & 0x00) 1615 { 1616 case 0x00: 1617 goto op_semantics_2; 1618 break; 1619 } 1620 break; 1621 case 0x48: 1622 GETBYTE (); 1623 switch (op[2] & 0x00) 1624 { 1625 case 0x00: 1626 goto op_semantics_3; 1627 break; 1628 } 1629 break; 1630 case 0x49: 1631 GETBYTE (); 1632 switch (op[2] & 0x00) 1633 { 1634 case 0x00: 1635 goto op_semantics_3; 1636 break; 1637 } 1638 break; 1639 case 0x4a: 1640 GETBYTE (); 1641 switch (op[2] & 0x00) 1642 { 1643 case 0x00: 1644 goto op_semantics_3; 1645 break; 1646 } 1647 break; 1648 case 0x4b: 1649 GETBYTE (); 1650 switch (op[2] & 0x00) 1651 { 1652 case 0x00: 1653 goto op_semantics_3; 1654 break; 1655 } 1656 break; 1657 case 0x4c: 1658 GETBYTE (); 1659 switch (op[2] & 0x00) 1660 { 1661 case 0x00: 1662 goto op_semantics_4; 1663 break; 1664 } 1665 break; 1666 case 0x4d: 1667 GETBYTE (); 1668 switch (op[2] & 0x00) 1669 { 1670 case 0x00: 1671 goto op_semantics_4; 1672 break; 1673 } 1674 break; 1675 case 0x4e: 1676 GETBYTE (); 1677 switch (op[2] & 0x00) 1678 { 1679 case 0x00: 1680 goto op_semantics_4; 1681 break; 1682 } 1683 break; 1684 case 0x4f: 1685 GETBYTE (); 1686 switch (op[2] & 0x00) 1687 { 1688 case 0x00: 1689 goto op_semantics_4; 1690 break; 1691 } 1692 break; 1693 case 0x50: 1694 GETBYTE (); 1695 switch (op[2] & 0x00) 1696 { 1697 case 0x00: 1698 goto op_semantics_5; 1699 break; 1700 } 1701 break; 1702 case 0x51: 1703 GETBYTE (); 1704 switch (op[2] & 0x00) 1705 { 1706 case 0x00: 1707 goto op_semantics_5; 1708 break; 1709 } 1710 break; 1711 case 0x52: 1712 GETBYTE (); 1713 switch (op[2] & 0x00) 1714 { 1715 case 0x00: 1716 goto op_semantics_5; 1717 break; 1718 } 1719 break; 1720 case 0x53: 1721 GETBYTE (); 1722 switch (op[2] & 0x00) 1723 { 1724 case 0x00: 1725 goto op_semantics_5; 1726 break; 1727 } 1728 break; 1729 case 0x54: 1730 GETBYTE (); 1731 switch (op[2] & 0x00) 1732 { 1733 case 0x00: 1734 goto op_semantics_6; 1735 break; 1736 } 1737 break; 1738 case 0x55: 1739 GETBYTE (); 1740 switch (op[2] & 0x00) 1741 { 1742 case 0x00: 1743 goto op_semantics_6; 1744 break; 1745 } 1746 break; 1747 case 0x56: 1748 GETBYTE (); 1749 switch (op[2] & 0x00) 1750 { 1751 case 0x00: 1752 goto op_semantics_6; 1753 break; 1754 } 1755 break; 1756 case 0x57: 1757 GETBYTE (); 1758 switch (op[2] & 0x00) 1759 { 1760 case 0x00: 1761 goto op_semantics_6; 1762 break; 1763 } 1764 break; 1765 case 0x60: 1766 GETBYTE (); 1767 switch (op[2] & 0xff) 1768 { 1769 case 0x00: 1770 GETBYTE (); 1771 switch (op[3] & 0x00) 1772 { 1773 case 0x00: 1774 goto op_semantics_7; 1775 break; 1776 } 1777 break; 1778 case 0x04: 1779 GETBYTE (); 1780 switch (op[3] & 0x00) 1781 { 1782 case 0x00: 1783 goto op_semantics_8; 1784 break; 1785 } 1786 break; 1787 case 0x05: 1788 GETBYTE (); 1789 switch (op[3] & 0x00) 1790 { 1791 case 0x00: 1792 goto op_semantics_9; 1793 break; 1794 } 1795 break; 1796 case 0x06: 1797 GETBYTE (); 1798 switch (op[3] & 0x00) 1799 { 1800 case 0x00: 1801 goto op_semantics_10; 1802 break; 1803 } 1804 break; 1805 case 0x07: 1806 GETBYTE (); 1807 switch (op[3] & 0x00) 1808 { 1809 case 0x00: 1810 goto op_semantics_11; 1811 break; 1812 } 1813 break; 1814 case 0x08: 1815 GETBYTE (); 1816 switch (op[3] & 0x00) 1817 { 1818 case 0x00: 1819 goto op_semantics_12; 1820 break; 1821 } 1822 break; 1823 case 0x09: 1824 GETBYTE (); 1825 switch (op[3] & 0x00) 1826 { 1827 case 0x00: 1828 goto op_semantics_13; 1829 break; 1830 } 1831 break; 1832 case 0x0c: 1833 GETBYTE (); 1834 switch (op[3] & 0x00) 1835 { 1836 case 0x00: 1837 goto op_semantics_14; 1838 break; 1839 } 1840 break; 1841 case 0x0d: 1842 GETBYTE (); 1843 switch (op[3] & 0x00) 1844 { 1845 case 0x00: 1846 goto op_semantics_15; 1847 break; 1848 } 1849 break; 1850 case 0x10: 1851 GETBYTE (); 1852 switch (op[3] & 0x00) 1853 { 1854 case 0x00: 1855 goto op_semantics_16; 1856 break; 1857 } 1858 break; 1859 case 0x11: 1860 GETBYTE (); 1861 switch (op[3] & 0x00) 1862 { 1863 case 0x00: 1864 goto op_semantics_17; 1865 break; 1866 } 1867 break; 1868 case 0x15: 1869 GETBYTE (); 1870 switch (op[3] & 0x00) 1871 { 1872 case 0x00: 1873 goto op_semantics_18; 1874 break; 1875 } 1876 break; 1877 default: UNSUPPORTED(); break; 1878 } 1879 break; 1880 case 0x61: 1881 GETBYTE (); 1882 switch (op[2] & 0xff) 1883 { 1884 case 0x00: 1885 GETBYTE (); 1886 switch (op[3] & 0x00) 1887 { 1888 case 0x00: 1889 goto op_semantics_7; 1890 break; 1891 } 1892 break; 1893 case 0x04: 1894 GETBYTE (); 1895 switch (op[3] & 0x00) 1896 { 1897 case 0x00: 1898 goto op_semantics_8; 1899 break; 1900 } 1901 break; 1902 case 0x05: 1903 GETBYTE (); 1904 switch (op[3] & 0x00) 1905 { 1906 case 0x00: 1907 goto op_semantics_9; 1908 break; 1909 } 1910 break; 1911 case 0x06: 1912 GETBYTE (); 1913 switch (op[3] & 0x00) 1914 { 1915 case 0x00: 1916 goto op_semantics_10; 1917 break; 1918 } 1919 break; 1920 case 0x07: 1921 GETBYTE (); 1922 switch (op[3] & 0x00) 1923 { 1924 case 0x00: 1925 goto op_semantics_11; 1926 break; 1927 } 1928 break; 1929 case 0x08: 1930 GETBYTE (); 1931 switch (op[3] & 0x00) 1932 { 1933 case 0x00: 1934 goto op_semantics_12; 1935 break; 1936 } 1937 break; 1938 case 0x09: 1939 GETBYTE (); 1940 switch (op[3] & 0x00) 1941 { 1942 case 0x00: 1943 goto op_semantics_13; 1944 break; 1945 } 1946 break; 1947 case 0x0c: 1948 GETBYTE (); 1949 switch (op[3] & 0x00) 1950 { 1951 case 0x00: 1952 goto op_semantics_14; 1953 break; 1954 } 1955 break; 1956 case 0x0d: 1957 GETBYTE (); 1958 switch (op[3] & 0x00) 1959 { 1960 case 0x00: 1961 goto op_semantics_15; 1962 break; 1963 } 1964 break; 1965 case 0x10: 1966 GETBYTE (); 1967 switch (op[3] & 0x00) 1968 { 1969 case 0x00: 1970 goto op_semantics_16; 1971 break; 1972 } 1973 break; 1974 case 0x11: 1975 GETBYTE (); 1976 switch (op[3] & 0x00) 1977 { 1978 case 0x00: 1979 goto op_semantics_17; 1980 break; 1981 } 1982 break; 1983 case 0x15: 1984 GETBYTE (); 1985 switch (op[3] & 0x00) 1986 { 1987 case 0x00: 1988 goto op_semantics_18; 1989 break; 1990 } 1991 break; 1992 default: UNSUPPORTED(); break; 1993 } 1994 break; 1995 case 0x62: 1996 GETBYTE (); 1997 switch (op[2] & 0xff) 1998 { 1999 case 0x00: 2000 GETBYTE (); 2001 switch (op[3] & 0x00) 2002 { 2003 case 0x00: 2004 goto op_semantics_7; 2005 break; 2006 } 2007 break; 2008 case 0x04: 2009 GETBYTE (); 2010 switch (op[3] & 0x00) 2011 { 2012 case 0x00: 2013 goto op_semantics_8; 2014 break; 2015 } 2016 break; 2017 case 0x05: 2018 GETBYTE (); 2019 switch (op[3] & 0x00) 2020 { 2021 case 0x00: 2022 goto op_semantics_9; 2023 break; 2024 } 2025 break; 2026 case 0x06: 2027 GETBYTE (); 2028 switch (op[3] & 0x00) 2029 { 2030 case 0x00: 2031 goto op_semantics_10; 2032 break; 2033 } 2034 break; 2035 case 0x07: 2036 GETBYTE (); 2037 switch (op[3] & 0x00) 2038 { 2039 case 0x00: 2040 goto op_semantics_11; 2041 break; 2042 } 2043 break; 2044 case 0x08: 2045 GETBYTE (); 2046 switch (op[3] & 0x00) 2047 { 2048 case 0x00: 2049 goto op_semantics_12; 2050 break; 2051 } 2052 break; 2053 case 0x09: 2054 GETBYTE (); 2055 switch (op[3] & 0x00) 2056 { 2057 case 0x00: 2058 goto op_semantics_13; 2059 break; 2060 } 2061 break; 2062 case 0x0c: 2063 GETBYTE (); 2064 switch (op[3] & 0x00) 2065 { 2066 case 0x00: 2067 goto op_semantics_14; 2068 break; 2069 } 2070 break; 2071 case 0x0d: 2072 GETBYTE (); 2073 switch (op[3] & 0x00) 2074 { 2075 case 0x00: 2076 goto op_semantics_15; 2077 break; 2078 } 2079 break; 2080 case 0x10: 2081 GETBYTE (); 2082 switch (op[3] & 0x00) 2083 { 2084 case 0x00: 2085 goto op_semantics_16; 2086 break; 2087 } 2088 break; 2089 case 0x11: 2090 GETBYTE (); 2091 switch (op[3] & 0x00) 2092 { 2093 case 0x00: 2094 goto op_semantics_17; 2095 break; 2096 } 2097 break; 2098 case 0x15: 2099 GETBYTE (); 2100 switch (op[3] & 0x00) 2101 { 2102 case 0x00: 2103 goto op_semantics_18; 2104 break; 2105 } 2106 break; 2107 default: UNSUPPORTED(); break; 2108 } 2109 break; 2110 case 0x63: 2111 GETBYTE (); 2112 switch (op[2] & 0xff) 2113 { 2114 case 0x00: 2115 GETBYTE (); 2116 switch (op[3] & 0x00) 2117 { 2118 case 0x00: 2119 goto op_semantics_7; 2120 break; 2121 } 2122 break; 2123 case 0x04: 2124 GETBYTE (); 2125 switch (op[3] & 0x00) 2126 { 2127 case 0x00: 2128 goto op_semantics_8; 2129 break; 2130 } 2131 break; 2132 case 0x05: 2133 GETBYTE (); 2134 switch (op[3] & 0x00) 2135 { 2136 case 0x00: 2137 goto op_semantics_9; 2138 break; 2139 } 2140 break; 2141 case 0x06: 2142 GETBYTE (); 2143 switch (op[3] & 0x00) 2144 { 2145 case 0x00: 2146 goto op_semantics_10; 2147 break; 2148 } 2149 break; 2150 case 0x07: 2151 GETBYTE (); 2152 switch (op[3] & 0x00) 2153 { 2154 case 0x00: 2155 goto op_semantics_11; 2156 break; 2157 } 2158 break; 2159 case 0x08: 2160 GETBYTE (); 2161 switch (op[3] & 0x00) 2162 { 2163 case 0x00: 2164 goto op_semantics_12; 2165 break; 2166 } 2167 break; 2168 case 0x09: 2169 GETBYTE (); 2170 switch (op[3] & 0x00) 2171 { 2172 case 0x00: 2173 goto op_semantics_13; 2174 break; 2175 } 2176 break; 2177 case 0x0c: 2178 GETBYTE (); 2179 switch (op[3] & 0x00) 2180 { 2181 case 0x00: 2182 goto op_semantics_14; 2183 break; 2184 } 2185 break; 2186 case 0x0d: 2187 GETBYTE (); 2188 switch (op[3] & 0x00) 2189 { 2190 case 0x00: 2191 goto op_semantics_15; 2192 break; 2193 } 2194 break; 2195 case 0x10: 2196 GETBYTE (); 2197 switch (op[3] & 0x00) 2198 { 2199 case 0x00: 2200 goto op_semantics_16; 2201 break; 2202 } 2203 break; 2204 case 0x11: 2205 GETBYTE (); 2206 switch (op[3] & 0x00) 2207 { 2208 case 0x00: 2209 goto op_semantics_17; 2210 break; 2211 } 2212 break; 2213 case 0x15: 2214 GETBYTE (); 2215 switch (op[3] & 0x00) 2216 { 2217 case 0x00: 2218 goto op_semantics_18; 2219 break; 2220 } 2221 break; 2222 default: UNSUPPORTED(); break; 2223 } 2224 break; 2225 case 0x80: 2226 GETBYTE (); 2227 switch (op[2] & 0x00) 2228 { 2229 case 0x00: 2230 goto op_semantics_1; 2231 break; 2232 } 2233 break; 2234 case 0x81: 2235 GETBYTE (); 2236 switch (op[2] & 0x00) 2237 { 2238 case 0x00: 2239 goto op_semantics_1; 2240 break; 2241 } 2242 break; 2243 case 0x82: 2244 GETBYTE (); 2245 switch (op[2] & 0x00) 2246 { 2247 case 0x00: 2248 goto op_semantics_1; 2249 break; 2250 } 2251 break; 2252 case 0x83: 2253 GETBYTE (); 2254 switch (op[2] & 0x00) 2255 { 2256 case 0x00: 2257 goto op_semantics_1; 2258 break; 2259 } 2260 break; 2261 case 0x84: 2262 GETBYTE (); 2263 switch (op[2] & 0x00) 2264 { 2265 case 0x00: 2266 goto op_semantics_2; 2267 break; 2268 } 2269 break; 2270 case 0x85: 2271 GETBYTE (); 2272 switch (op[2] & 0x00) 2273 { 2274 case 0x00: 2275 goto op_semantics_2; 2276 break; 2277 } 2278 break; 2279 case 0x86: 2280 GETBYTE (); 2281 switch (op[2] & 0x00) 2282 { 2283 case 0x00: 2284 goto op_semantics_2; 2285 break; 2286 } 2287 break; 2288 case 0x87: 2289 GETBYTE (); 2290 switch (op[2] & 0x00) 2291 { 2292 case 0x00: 2293 goto op_semantics_2; 2294 break; 2295 } 2296 break; 2297 case 0x88: 2298 GETBYTE (); 2299 switch (op[2] & 0x00) 2300 { 2301 case 0x00: 2302 goto op_semantics_3; 2303 break; 2304 } 2305 break; 2306 case 0x89: 2307 GETBYTE (); 2308 switch (op[2] & 0x00) 2309 { 2310 case 0x00: 2311 goto op_semantics_3; 2312 break; 2313 } 2314 break; 2315 case 0x8a: 2316 GETBYTE (); 2317 switch (op[2] & 0x00) 2318 { 2319 case 0x00: 2320 goto op_semantics_3; 2321 break; 2322 } 2323 break; 2324 case 0x8b: 2325 GETBYTE (); 2326 switch (op[2] & 0x00) 2327 { 2328 case 0x00: 2329 goto op_semantics_3; 2330 break; 2331 } 2332 break; 2333 case 0x8c: 2334 GETBYTE (); 2335 switch (op[2] & 0x00) 2336 { 2337 case 0x00: 2338 goto op_semantics_4; 2339 break; 2340 } 2341 break; 2342 case 0x8d: 2343 GETBYTE (); 2344 switch (op[2] & 0x00) 2345 { 2346 case 0x00: 2347 goto op_semantics_4; 2348 break; 2349 } 2350 break; 2351 case 0x8e: 2352 GETBYTE (); 2353 switch (op[2] & 0x00) 2354 { 2355 case 0x00: 2356 goto op_semantics_4; 2357 break; 2358 } 2359 break; 2360 case 0x8f: 2361 GETBYTE (); 2362 switch (op[2] & 0x00) 2363 { 2364 case 0x00: 2365 goto op_semantics_4; 2366 break; 2367 } 2368 break; 2369 case 0x90: 2370 GETBYTE (); 2371 switch (op[2] & 0x00) 2372 { 2373 case 0x00: 2374 goto op_semantics_5; 2375 break; 2376 } 2377 break; 2378 case 0x91: 2379 GETBYTE (); 2380 switch (op[2] & 0x00) 2381 { 2382 case 0x00: 2383 goto op_semantics_5; 2384 break; 2385 } 2386 break; 2387 case 0x92: 2388 GETBYTE (); 2389 switch (op[2] & 0x00) 2390 { 2391 case 0x00: 2392 goto op_semantics_5; 2393 break; 2394 } 2395 break; 2396 case 0x93: 2397 GETBYTE (); 2398 switch (op[2] & 0x00) 2399 { 2400 case 0x00: 2401 goto op_semantics_5; 2402 break; 2403 } 2404 break; 2405 case 0x94: 2406 GETBYTE (); 2407 switch (op[2] & 0x00) 2408 { 2409 case 0x00: 2410 goto op_semantics_6; 2411 break; 2412 } 2413 break; 2414 case 0x95: 2415 GETBYTE (); 2416 switch (op[2] & 0x00) 2417 { 2418 case 0x00: 2419 goto op_semantics_6; 2420 break; 2421 } 2422 break; 2423 case 0x96: 2424 GETBYTE (); 2425 switch (op[2] & 0x00) 2426 { 2427 case 0x00: 2428 goto op_semantics_6; 2429 break; 2430 } 2431 break; 2432 case 0x97: 2433 GETBYTE (); 2434 switch (op[2] & 0x00) 2435 { 2436 case 0x00: 2437 goto op_semantics_6; 2438 break; 2439 } 2440 break; 2441 case 0xa0: 2442 GETBYTE (); 2443 switch (op[2] & 0xff) 2444 { 2445 case 0x00: 2446 GETBYTE (); 2447 switch (op[3] & 0x00) 2448 { 2449 case 0x00: 2450 goto op_semantics_7; 2451 break; 2452 } 2453 break; 2454 case 0x02: 2455 GETBYTE (); 2456 switch (op[3] & 0x00) 2457 { 2458 case 0x00: 2459 op_semantics_19: 2460 { 2461 /** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */ 2462 #line 494 "rx-decode.opc" 2463 int ss AU = op[1] & 0x03; 2464 #line 494 "rx-decode.opc" 2465 int rsrc AU = (op[3] >> 4) & 0x0f; 2466 #line 494 "rx-decode.opc" 2467 int rdst AU = op[3] & 0x0f; 2468 if (trace) 2469 { 2470 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 2471 "/** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */", 2472 op[0], op[1], op[2], op[3]); 2473 printf (" ss = 0x%x,", ss); 2474 printf (" rsrc = 0x%x,", rsrc); 2475 printf (" rdst = 0x%x\n", rdst); 2476 } 2477 SYNTAX("adc %1%S1, %0"); 2478 #line 494 "rx-decode.opc" 2479 ID(adc); SPm(ss, rsrc, 2); DR(rdst); F_OSZC; 2480 2481 /*----------------------------------------------------------------------*/ 2482 /* ADD */ 2483 2484 } 2485 break; 2486 } 2487 break; 2488 case 0x04: 2489 GETBYTE (); 2490 switch (op[3] & 0x00) 2491 { 2492 case 0x00: 2493 goto op_semantics_8; 2494 break; 2495 } 2496 break; 2497 case 0x05: 2498 GETBYTE (); 2499 switch (op[3] & 0x00) 2500 { 2501 case 0x00: 2502 goto op_semantics_9; 2503 break; 2504 } 2505 break; 2506 case 0x06: 2507 GETBYTE (); 2508 switch (op[3] & 0x00) 2509 { 2510 case 0x00: 2511 goto op_semantics_10; 2512 break; 2513 } 2514 break; 2515 case 0x07: 2516 GETBYTE (); 2517 switch (op[3] & 0x00) 2518 { 2519 case 0x00: 2520 goto op_semantics_11; 2521 break; 2522 } 2523 break; 2524 case 0x08: 2525 GETBYTE (); 2526 switch (op[3] & 0x00) 2527 { 2528 case 0x00: 2529 goto op_semantics_12; 2530 break; 2531 } 2532 break; 2533 case 0x09: 2534 GETBYTE (); 2535 switch (op[3] & 0x00) 2536 { 2537 case 0x00: 2538 goto op_semantics_13; 2539 break; 2540 } 2541 break; 2542 case 0x0c: 2543 GETBYTE (); 2544 switch (op[3] & 0x00) 2545 { 2546 case 0x00: 2547 goto op_semantics_14; 2548 break; 2549 } 2550 break; 2551 case 0x0d: 2552 GETBYTE (); 2553 switch (op[3] & 0x00) 2554 { 2555 case 0x00: 2556 goto op_semantics_15; 2557 break; 2558 } 2559 break; 2560 case 0x10: 2561 GETBYTE (); 2562 switch (op[3] & 0x00) 2563 { 2564 case 0x00: 2565 goto op_semantics_16; 2566 break; 2567 } 2568 break; 2569 case 0x11: 2570 GETBYTE (); 2571 switch (op[3] & 0x00) 2572 { 2573 case 0x00: 2574 goto op_semantics_17; 2575 break; 2576 } 2577 break; 2578 case 0x15: 2579 GETBYTE (); 2580 switch (op[3] & 0x00) 2581 { 2582 case 0x00: 2583 goto op_semantics_18; 2584 break; 2585 } 2586 break; 2587 default: UNSUPPORTED(); break; 2588 } 2589 break; 2590 case 0xa1: 2591 GETBYTE (); 2592 switch (op[2] & 0xff) 2593 { 2594 case 0x00: 2595 GETBYTE (); 2596 switch (op[3] & 0x00) 2597 { 2598 case 0x00: 2599 goto op_semantics_7; 2600 break; 2601 } 2602 break; 2603 case 0x02: 2604 GETBYTE (); 2605 switch (op[3] & 0x00) 2606 { 2607 case 0x00: 2608 goto op_semantics_19; 2609 break; 2610 } 2611 break; 2612 case 0x04: 2613 GETBYTE (); 2614 switch (op[3] & 0x00) 2615 { 2616 case 0x00: 2617 goto op_semantics_8; 2618 break; 2619 } 2620 break; 2621 case 0x05: 2622 GETBYTE (); 2623 switch (op[3] & 0x00) 2624 { 2625 case 0x00: 2626 goto op_semantics_9; 2627 break; 2628 } 2629 break; 2630 case 0x06: 2631 GETBYTE (); 2632 switch (op[3] & 0x00) 2633 { 2634 case 0x00: 2635 goto op_semantics_10; 2636 break; 2637 } 2638 break; 2639 case 0x07: 2640 GETBYTE (); 2641 switch (op[3] & 0x00) 2642 { 2643 case 0x00: 2644 goto op_semantics_11; 2645 break; 2646 } 2647 break; 2648 case 0x08: 2649 GETBYTE (); 2650 switch (op[3] & 0x00) 2651 { 2652 case 0x00: 2653 goto op_semantics_12; 2654 break; 2655 } 2656 break; 2657 case 0x09: 2658 GETBYTE (); 2659 switch (op[3] & 0x00) 2660 { 2661 case 0x00: 2662 goto op_semantics_13; 2663 break; 2664 } 2665 break; 2666 case 0x0c: 2667 GETBYTE (); 2668 switch (op[3] & 0x00) 2669 { 2670 case 0x00: 2671 goto op_semantics_14; 2672 break; 2673 } 2674 break; 2675 case 0x0d: 2676 GETBYTE (); 2677 switch (op[3] & 0x00) 2678 { 2679 case 0x00: 2680 goto op_semantics_15; 2681 break; 2682 } 2683 break; 2684 case 0x10: 2685 GETBYTE (); 2686 switch (op[3] & 0x00) 2687 { 2688 case 0x00: 2689 goto op_semantics_16; 2690 break; 2691 } 2692 break; 2693 case 0x11: 2694 GETBYTE (); 2695 switch (op[3] & 0x00) 2696 { 2697 case 0x00: 2698 goto op_semantics_17; 2699 break; 2700 } 2701 break; 2702 case 0x15: 2703 GETBYTE (); 2704 switch (op[3] & 0x00) 2705 { 2706 case 0x00: 2707 goto op_semantics_18; 2708 break; 2709 } 2710 break; 2711 default: UNSUPPORTED(); break; 2712 } 2713 break; 2714 case 0xa2: 2715 GETBYTE (); 2716 switch (op[2] & 0xff) 2717 { 2718 case 0x00: 2719 GETBYTE (); 2720 switch (op[3] & 0x00) 2721 { 2722 case 0x00: 2723 goto op_semantics_7; 2724 break; 2725 } 2726 break; 2727 case 0x02: 2728 GETBYTE (); 2729 switch (op[3] & 0x00) 2730 { 2731 case 0x00: 2732 goto op_semantics_19; 2733 break; 2734 } 2735 break; 2736 case 0x04: 2737 GETBYTE (); 2738 switch (op[3] & 0x00) 2739 { 2740 case 0x00: 2741 goto op_semantics_8; 2742 break; 2743 } 2744 break; 2745 case 0x05: 2746 GETBYTE (); 2747 switch (op[3] & 0x00) 2748 { 2749 case 0x00: 2750 goto op_semantics_9; 2751 break; 2752 } 2753 break; 2754 case 0x06: 2755 GETBYTE (); 2756 switch (op[3] & 0x00) 2757 { 2758 case 0x00: 2759 goto op_semantics_10; 2760 break; 2761 } 2762 break; 2763 case 0x07: 2764 GETBYTE (); 2765 switch (op[3] & 0x00) 2766 { 2767 case 0x00: 2768 goto op_semantics_11; 2769 break; 2770 } 2771 break; 2772 case 0x08: 2773 GETBYTE (); 2774 switch (op[3] & 0x00) 2775 { 2776 case 0x00: 2777 goto op_semantics_12; 2778 break; 2779 } 2780 break; 2781 case 0x09: 2782 GETBYTE (); 2783 switch (op[3] & 0x00) 2784 { 2785 case 0x00: 2786 goto op_semantics_13; 2787 break; 2788 } 2789 break; 2790 case 0x0c: 2791 GETBYTE (); 2792 switch (op[3] & 0x00) 2793 { 2794 case 0x00: 2795 goto op_semantics_14; 2796 break; 2797 } 2798 break; 2799 case 0x0d: 2800 GETBYTE (); 2801 switch (op[3] & 0x00) 2802 { 2803 case 0x00: 2804 goto op_semantics_15; 2805 break; 2806 } 2807 break; 2808 case 0x10: 2809 GETBYTE (); 2810 switch (op[3] & 0x00) 2811 { 2812 case 0x00: 2813 goto op_semantics_16; 2814 break; 2815 } 2816 break; 2817 case 0x11: 2818 GETBYTE (); 2819 switch (op[3] & 0x00) 2820 { 2821 case 0x00: 2822 goto op_semantics_17; 2823 break; 2824 } 2825 break; 2826 case 0x15: 2827 GETBYTE (); 2828 switch (op[3] & 0x00) 2829 { 2830 case 0x00: 2831 goto op_semantics_18; 2832 break; 2833 } 2834 break; 2835 default: UNSUPPORTED(); break; 2836 } 2837 break; 2838 case 0xa3: 2839 GETBYTE (); 2840 switch (op[2] & 0xff) 2841 { 2842 case 0x00: 2843 GETBYTE (); 2844 switch (op[3] & 0x00) 2845 { 2846 case 0x00: 2847 goto op_semantics_7; 2848 break; 2849 } 2850 break; 2851 case 0x02: 2852 GETBYTE (); 2853 switch (op[3] & 0x00) 2854 { 2855 case 0x00: 2856 goto op_semantics_19; 2857 break; 2858 } 2859 break; 2860 case 0x04: 2861 GETBYTE (); 2862 switch (op[3] & 0x00) 2863 { 2864 case 0x00: 2865 goto op_semantics_8; 2866 break; 2867 } 2868 break; 2869 case 0x05: 2870 GETBYTE (); 2871 switch (op[3] & 0x00) 2872 { 2873 case 0x00: 2874 goto op_semantics_9; 2875 break; 2876 } 2877 break; 2878 case 0x06: 2879 GETBYTE (); 2880 switch (op[3] & 0x00) 2881 { 2882 case 0x00: 2883 goto op_semantics_10; 2884 break; 2885 } 2886 break; 2887 case 0x07: 2888 GETBYTE (); 2889 switch (op[3] & 0x00) 2890 { 2891 case 0x00: 2892 goto op_semantics_11; 2893 break; 2894 } 2895 break; 2896 case 0x08: 2897 GETBYTE (); 2898 switch (op[3] & 0x00) 2899 { 2900 case 0x00: 2901 goto op_semantics_12; 2902 break; 2903 } 2904 break; 2905 case 0x09: 2906 GETBYTE (); 2907 switch (op[3] & 0x00) 2908 { 2909 case 0x00: 2910 goto op_semantics_13; 2911 break; 2912 } 2913 break; 2914 case 0x0c: 2915 GETBYTE (); 2916 switch (op[3] & 0x00) 2917 { 2918 case 0x00: 2919 goto op_semantics_14; 2920 break; 2921 } 2922 break; 2923 case 0x0d: 2924 GETBYTE (); 2925 switch (op[3] & 0x00) 2926 { 2927 case 0x00: 2928 goto op_semantics_15; 2929 break; 2930 } 2931 break; 2932 case 0x10: 2933 GETBYTE (); 2934 switch (op[3] & 0x00) 2935 { 2936 case 0x00: 2937 goto op_semantics_16; 2938 break; 2939 } 2940 break; 2941 case 0x11: 2942 GETBYTE (); 2943 switch (op[3] & 0x00) 2944 { 2945 case 0x00: 2946 goto op_semantics_17; 2947 break; 2948 } 2949 break; 2950 case 0x15: 2951 GETBYTE (); 2952 switch (op[3] & 0x00) 2953 { 2954 case 0x00: 2955 goto op_semantics_18; 2956 break; 2957 } 2958 break; 2959 default: UNSUPPORTED(); break; 2960 } 2961 break; 2962 case 0xc0: 2963 GETBYTE (); 2964 switch (op[2] & 0x00) 2965 { 2966 case 0x00: 2967 goto op_semantics_1; 2968 break; 2969 } 2970 break; 2971 case 0xc1: 2972 GETBYTE (); 2973 switch (op[2] & 0x00) 2974 { 2975 case 0x00: 2976 goto op_semantics_1; 2977 break; 2978 } 2979 break; 2980 case 0xc2: 2981 GETBYTE (); 2982 switch (op[2] & 0x00) 2983 { 2984 case 0x00: 2985 goto op_semantics_1; 2986 break; 2987 } 2988 break; 2989 case 0xc3: 2990 GETBYTE (); 2991 switch (op[2] & 0x00) 2992 { 2993 case 0x00: 2994 goto op_semantics_1; 2995 break; 2996 } 2997 break; 2998 case 0xc4: 2999 GETBYTE (); 3000 switch (op[2] & 0x00) 3001 { 3002 case 0x00: 3003 goto op_semantics_2; 3004 break; 3005 } 3006 break; 3007 case 0xc5: 3008 GETBYTE (); 3009 switch (op[2] & 0x00) 3010 { 3011 case 0x00: 3012 goto op_semantics_2; 3013 break; 3014 } 3015 break; 3016 case 0xc6: 3017 GETBYTE (); 3018 switch (op[2] & 0x00) 3019 { 3020 case 0x00: 3021 goto op_semantics_2; 3022 break; 3023 } 3024 break; 3025 case 0xc7: 3026 GETBYTE (); 3027 switch (op[2] & 0x00) 3028 { 3029 case 0x00: 3030 goto op_semantics_2; 3031 break; 3032 } 3033 break; 3034 case 0xc8: 3035 GETBYTE (); 3036 switch (op[2] & 0x00) 3037 { 3038 case 0x00: 3039 goto op_semantics_3; 3040 break; 3041 } 3042 break; 3043 case 0xc9: 3044 GETBYTE (); 3045 switch (op[2] & 0x00) 3046 { 3047 case 0x00: 3048 goto op_semantics_3; 3049 break; 3050 } 3051 break; 3052 case 0xca: 3053 GETBYTE (); 3054 switch (op[2] & 0x00) 3055 { 3056 case 0x00: 3057 goto op_semantics_3; 3058 break; 3059 } 3060 break; 3061 case 0xcb: 3062 GETBYTE (); 3063 switch (op[2] & 0x00) 3064 { 3065 case 0x00: 3066 goto op_semantics_3; 3067 break; 3068 } 3069 break; 3070 case 0xcc: 3071 GETBYTE (); 3072 switch (op[2] & 0x00) 3073 { 3074 case 0x00: 3075 goto op_semantics_4; 3076 break; 3077 } 3078 break; 3079 case 0xcd: 3080 GETBYTE (); 3081 switch (op[2] & 0x00) 3082 { 3083 case 0x00: 3084 goto op_semantics_4; 3085 break; 3086 } 3087 break; 3088 case 0xce: 3089 GETBYTE (); 3090 switch (op[2] & 0x00) 3091 { 3092 case 0x00: 3093 goto op_semantics_4; 3094 break; 3095 } 3096 break; 3097 case 0xcf: 3098 GETBYTE (); 3099 switch (op[2] & 0x00) 3100 { 3101 case 0x00: 3102 goto op_semantics_4; 3103 break; 3104 } 3105 break; 3106 case 0xd0: 3107 GETBYTE (); 3108 switch (op[2] & 0x00) 3109 { 3110 case 0x00: 3111 goto op_semantics_5; 3112 break; 3113 } 3114 break; 3115 case 0xd1: 3116 GETBYTE (); 3117 switch (op[2] & 0x00) 3118 { 3119 case 0x00: 3120 goto op_semantics_5; 3121 break; 3122 } 3123 break; 3124 case 0xd2: 3125 GETBYTE (); 3126 switch (op[2] & 0x00) 3127 { 3128 case 0x00: 3129 goto op_semantics_5; 3130 break; 3131 } 3132 break; 3133 case 0xd3: 3134 GETBYTE (); 3135 switch (op[2] & 0x00) 3136 { 3137 case 0x00: 3138 goto op_semantics_5; 3139 break; 3140 } 3141 break; 3142 case 0xd4: 3143 GETBYTE (); 3144 switch (op[2] & 0x00) 3145 { 3146 case 0x00: 3147 goto op_semantics_6; 3148 break; 3149 } 3150 break; 3151 case 0xd5: 3152 GETBYTE (); 3153 switch (op[2] & 0x00) 3154 { 3155 case 0x00: 3156 goto op_semantics_6; 3157 break; 3158 } 3159 break; 3160 case 0xd6: 3161 GETBYTE (); 3162 switch (op[2] & 0x00) 3163 { 3164 case 0x00: 3165 goto op_semantics_6; 3166 break; 3167 } 3168 break; 3169 case 0xd7: 3170 GETBYTE (); 3171 switch (op[2] & 0x00) 3172 { 3173 case 0x00: 3174 goto op_semantics_6; 3175 break; 3176 } 3177 break; 3178 case 0xe0: 3179 GETBYTE (); 3180 switch (op[2] & 0xff) 3181 { 3182 case 0x00: 3183 GETBYTE (); 3184 switch (op[3] & 0x00) 3185 { 3186 case 0x00: 3187 goto op_semantics_7; 3188 break; 3189 } 3190 break; 3191 case 0x04: 3192 GETBYTE (); 3193 switch (op[3] & 0x00) 3194 { 3195 case 0x00: 3196 goto op_semantics_8; 3197 break; 3198 } 3199 break; 3200 case 0x05: 3201 GETBYTE (); 3202 switch (op[3] & 0x00) 3203 { 3204 case 0x00: 3205 goto op_semantics_9; 3206 break; 3207 } 3208 break; 3209 case 0x06: 3210 GETBYTE (); 3211 switch (op[3] & 0x00) 3212 { 3213 case 0x00: 3214 goto op_semantics_10; 3215 break; 3216 } 3217 break; 3218 case 0x07: 3219 GETBYTE (); 3220 switch (op[3] & 0x00) 3221 { 3222 case 0x00: 3223 goto op_semantics_11; 3224 break; 3225 } 3226 break; 3227 case 0x08: 3228 GETBYTE (); 3229 switch (op[3] & 0x00) 3230 { 3231 case 0x00: 3232 goto op_semantics_12; 3233 break; 3234 } 3235 break; 3236 case 0x09: 3237 GETBYTE (); 3238 switch (op[3] & 0x00) 3239 { 3240 case 0x00: 3241 goto op_semantics_13; 3242 break; 3243 } 3244 break; 3245 case 0x0c: 3246 GETBYTE (); 3247 switch (op[3] & 0x00) 3248 { 3249 case 0x00: 3250 goto op_semantics_14; 3251 break; 3252 } 3253 break; 3254 case 0x0d: 3255 GETBYTE (); 3256 switch (op[3] & 0x00) 3257 { 3258 case 0x00: 3259 goto op_semantics_15; 3260 break; 3261 } 3262 break; 3263 case 0x10: 3264 GETBYTE (); 3265 switch (op[3] & 0x00) 3266 { 3267 case 0x00: 3268 goto op_semantics_16; 3269 break; 3270 } 3271 break; 3272 case 0x11: 3273 GETBYTE (); 3274 switch (op[3] & 0x00) 3275 { 3276 case 0x00: 3277 goto op_semantics_17; 3278 break; 3279 } 3280 break; 3281 case 0x15: 3282 GETBYTE (); 3283 switch (op[3] & 0x00) 3284 { 3285 case 0x00: 3286 goto op_semantics_18; 3287 break; 3288 } 3289 break; 3290 default: UNSUPPORTED(); break; 3291 } 3292 break; 3293 case 0xe1: 3294 GETBYTE (); 3295 switch (op[2] & 0xff) 3296 { 3297 case 0x00: 3298 GETBYTE (); 3299 switch (op[3] & 0x00) 3300 { 3301 case 0x00: 3302 goto op_semantics_7; 3303 break; 3304 } 3305 break; 3306 case 0x04: 3307 GETBYTE (); 3308 switch (op[3] & 0x00) 3309 { 3310 case 0x00: 3311 goto op_semantics_8; 3312 break; 3313 } 3314 break; 3315 case 0x05: 3316 GETBYTE (); 3317 switch (op[3] & 0x00) 3318 { 3319 case 0x00: 3320 goto op_semantics_9; 3321 break; 3322 } 3323 break; 3324 case 0x06: 3325 GETBYTE (); 3326 switch (op[3] & 0x00) 3327 { 3328 case 0x00: 3329 goto op_semantics_10; 3330 break; 3331 } 3332 break; 3333 case 0x07: 3334 GETBYTE (); 3335 switch (op[3] & 0x00) 3336 { 3337 case 0x00: 3338 goto op_semantics_11; 3339 break; 3340 } 3341 break; 3342 case 0x08: 3343 GETBYTE (); 3344 switch (op[3] & 0x00) 3345 { 3346 case 0x00: 3347 goto op_semantics_12; 3348 break; 3349 } 3350 break; 3351 case 0x09: 3352 GETBYTE (); 3353 switch (op[3] & 0x00) 3354 { 3355 case 0x00: 3356 goto op_semantics_13; 3357 break; 3358 } 3359 break; 3360 case 0x0c: 3361 GETBYTE (); 3362 switch (op[3] & 0x00) 3363 { 3364 case 0x00: 3365 goto op_semantics_14; 3366 break; 3367 } 3368 break; 3369 case 0x0d: 3370 GETBYTE (); 3371 switch (op[3] & 0x00) 3372 { 3373 case 0x00: 3374 goto op_semantics_15; 3375 break; 3376 } 3377 break; 3378 case 0x10: 3379 GETBYTE (); 3380 switch (op[3] & 0x00) 3381 { 3382 case 0x00: 3383 goto op_semantics_16; 3384 break; 3385 } 3386 break; 3387 case 0x11: 3388 GETBYTE (); 3389 switch (op[3] & 0x00) 3390 { 3391 case 0x00: 3392 goto op_semantics_17; 3393 break; 3394 } 3395 break; 3396 case 0x15: 3397 GETBYTE (); 3398 switch (op[3] & 0x00) 3399 { 3400 case 0x00: 3401 goto op_semantics_18; 3402 break; 3403 } 3404 break; 3405 default: UNSUPPORTED(); break; 3406 } 3407 break; 3408 case 0xe2: 3409 GETBYTE (); 3410 switch (op[2] & 0xff) 3411 { 3412 case 0x00: 3413 GETBYTE (); 3414 switch (op[3] & 0x00) 3415 { 3416 case 0x00: 3417 goto op_semantics_7; 3418 break; 3419 } 3420 break; 3421 case 0x04: 3422 GETBYTE (); 3423 switch (op[3] & 0x00) 3424 { 3425 case 0x00: 3426 goto op_semantics_8; 3427 break; 3428 } 3429 break; 3430 case 0x05: 3431 GETBYTE (); 3432 switch (op[3] & 0x00) 3433 { 3434 case 0x00: 3435 goto op_semantics_9; 3436 break; 3437 } 3438 break; 3439 case 0x06: 3440 GETBYTE (); 3441 switch (op[3] & 0x00) 3442 { 3443 case 0x00: 3444 goto op_semantics_10; 3445 break; 3446 } 3447 break; 3448 case 0x07: 3449 GETBYTE (); 3450 switch (op[3] & 0x00) 3451 { 3452 case 0x00: 3453 goto op_semantics_11; 3454 break; 3455 } 3456 break; 3457 case 0x08: 3458 GETBYTE (); 3459 switch (op[3] & 0x00) 3460 { 3461 case 0x00: 3462 goto op_semantics_12; 3463 break; 3464 } 3465 break; 3466 case 0x09: 3467 GETBYTE (); 3468 switch (op[3] & 0x00) 3469 { 3470 case 0x00: 3471 goto op_semantics_13; 3472 break; 3473 } 3474 break; 3475 case 0x0c: 3476 GETBYTE (); 3477 switch (op[3] & 0x00) 3478 { 3479 case 0x00: 3480 goto op_semantics_14; 3481 break; 3482 } 3483 break; 3484 case 0x0d: 3485 GETBYTE (); 3486 switch (op[3] & 0x00) 3487 { 3488 case 0x00: 3489 goto op_semantics_15; 3490 break; 3491 } 3492 break; 3493 case 0x10: 3494 GETBYTE (); 3495 switch (op[3] & 0x00) 3496 { 3497 case 0x00: 3498 goto op_semantics_16; 3499 break; 3500 } 3501 break; 3502 case 0x11: 3503 GETBYTE (); 3504 switch (op[3] & 0x00) 3505 { 3506 case 0x00: 3507 goto op_semantics_17; 3508 break; 3509 } 3510 break; 3511 case 0x15: 3512 GETBYTE (); 3513 switch (op[3] & 0x00) 3514 { 3515 case 0x00: 3516 goto op_semantics_18; 3517 break; 3518 } 3519 break; 3520 default: UNSUPPORTED(); break; 3521 } 3522 break; 3523 case 0xe3: 3524 GETBYTE (); 3525 switch (op[2] & 0xff) 3526 { 3527 case 0x00: 3528 GETBYTE (); 3529 switch (op[3] & 0x00) 3530 { 3531 case 0x00: 3532 goto op_semantics_7; 3533 break; 3534 } 3535 break; 3536 case 0x04: 3537 GETBYTE (); 3538 switch (op[3] & 0x00) 3539 { 3540 case 0x00: 3541 goto op_semantics_8; 3542 break; 3543 } 3544 break; 3545 case 0x05: 3546 GETBYTE (); 3547 switch (op[3] & 0x00) 3548 { 3549 case 0x00: 3550 goto op_semantics_9; 3551 break; 3552 } 3553 break; 3554 case 0x06: 3555 GETBYTE (); 3556 switch (op[3] & 0x00) 3557 { 3558 case 0x00: 3559 goto op_semantics_10; 3560 break; 3561 } 3562 break; 3563 case 0x07: 3564 GETBYTE (); 3565 switch (op[3] & 0x00) 3566 { 3567 case 0x00: 3568 goto op_semantics_11; 3569 break; 3570 } 3571 break; 3572 case 0x08: 3573 GETBYTE (); 3574 switch (op[3] & 0x00) 3575 { 3576 case 0x00: 3577 goto op_semantics_12; 3578 break; 3579 } 3580 break; 3581 case 0x09: 3582 GETBYTE (); 3583 switch (op[3] & 0x00) 3584 { 3585 case 0x00: 3586 goto op_semantics_13; 3587 break; 3588 } 3589 break; 3590 case 0x0c: 3591 GETBYTE (); 3592 switch (op[3] & 0x00) 3593 { 3594 case 0x00: 3595 goto op_semantics_14; 3596 break; 3597 } 3598 break; 3599 case 0x0d: 3600 GETBYTE (); 3601 switch (op[3] & 0x00) 3602 { 3603 case 0x00: 3604 goto op_semantics_15; 3605 break; 3606 } 3607 break; 3608 case 0x10: 3609 GETBYTE (); 3610 switch (op[3] & 0x00) 3611 { 3612 case 0x00: 3613 goto op_semantics_16; 3614 break; 3615 } 3616 break; 3617 case 0x11: 3618 GETBYTE (); 3619 switch (op[3] & 0x00) 3620 { 3621 case 0x00: 3622 goto op_semantics_17; 3623 break; 3624 } 3625 break; 3626 case 0x15: 3627 GETBYTE (); 3628 switch (op[3] & 0x00) 3629 { 3630 case 0x00: 3631 goto op_semantics_18; 3632 break; 3633 } 3634 break; 3635 default: UNSUPPORTED(); break; 3636 } 3637 break; 3638 default: UNSUPPORTED(); break; 3639 } 3640 break; 3641 case 0x08: 3642 case 0x09: 3643 case 0x0a: 3644 case 0x0b: 3645 case 0x0c: 3646 case 0x0d: 3647 case 0x0e: 3648 case 0x0f: 3649 { 3650 /** 0000 1dsp bra.s %a0 */ 3651 #line 775 "rx-decode.opc" 3652 int dsp AU = op[0] & 0x07; 3653 if (trace) 3654 { 3655 printf ("\033[33m%s\033[0m %02x\n", 3656 "/** 0000 1dsp bra.s %a0 */", 3657 op[0]); 3658 printf (" dsp = 0x%x\n", dsp); 3659 } 3660 SYNTAX("bra.s %a0"); 3661 #line 775 "rx-decode.opc" 3662 ID(branch); DC(pc + dsp3map[dsp]); 3663 3664 } 3665 break; 3666 case 0x10: 3667 case 0x11: 3668 case 0x12: 3669 case 0x13: 3670 case 0x14: 3671 case 0x15: 3672 case 0x16: 3673 case 0x17: 3674 case 0x18: 3675 case 0x19: 3676 case 0x1a: 3677 case 0x1b: 3678 case 0x1c: 3679 case 0x1d: 3680 case 0x1e: 3681 case 0x1f: 3682 { 3683 /** 0001 n dsp b%1.s %a0 */ 3684 #line 765 "rx-decode.opc" 3685 int n AU = (op[0] >> 3) & 0x01; 3686 #line 765 "rx-decode.opc" 3687 int dsp AU = op[0] & 0x07; 3688 if (trace) 3689 { 3690 printf ("\033[33m%s\033[0m %02x\n", 3691 "/** 0001 n dsp b%1.s %a0 */", 3692 op[0]); 3693 printf (" n = 0x%x,", n); 3694 printf (" dsp = 0x%x\n", dsp); 3695 } 3696 SYNTAX("b%1.s %a0"); 3697 #line 765 "rx-decode.opc" 3698 ID(branch); Scc(n); DC(pc + dsp3map[dsp]); 3699 3700 } 3701 break; 3702 case 0x20: 3703 case 0x21: 3704 case 0x22: 3705 case 0x23: 3706 case 0x24: 3707 case 0x25: 3708 case 0x26: 3709 case 0x27: 3710 case 0x28: 3711 case 0x29: 3712 case 0x2a: 3713 case 0x2b: 3714 case 0x2c: 3715 case 0x2d: 3716 case 0x2f: 3717 { 3718 /** 0010 cond b%1.b %a0 */ 3719 #line 768 "rx-decode.opc" 3720 int cond AU = op[0] & 0x0f; 3721 if (trace) 3722 { 3723 printf ("\033[33m%s\033[0m %02x\n", 3724 "/** 0010 cond b%1.b %a0 */", 3725 op[0]); 3726 printf (" cond = 0x%x\n", cond); 3727 } 3728 SYNTAX("b%1.b %a0"); 3729 #line 768 "rx-decode.opc" 3730 ID(branch); Scc(cond); DC(pc + IMMex (1)); 3731 3732 } 3733 break; 3734 case 0x2e: 3735 { 3736 /** 0010 1110 bra.b %a0 */ 3737 if (trace) 3738 { 3739 printf ("\033[33m%s\033[0m %02x\n", 3740 "/** 0010 1110 bra.b %a0 */", 3741 op[0]); 3742 } 3743 SYNTAX("bra.b %a0"); 3744 #line 778 "rx-decode.opc" 3745 ID(branch); DC(pc + IMMex(1)); 3746 3747 } 3748 break; 3749 case 0x38: 3750 { 3751 /** 0011 1000 bra.w %a0 */ 3752 if (trace) 3753 { 3754 printf ("\033[33m%s\033[0m %02x\n", 3755 "/** 0011 1000 bra.w %a0 */", 3756 op[0]); 3757 } 3758 SYNTAX("bra.w %a0"); 3759 #line 781 "rx-decode.opc" 3760 ID(branch); DC(pc + IMMex(2)); 3761 3762 } 3763 break; 3764 case 0x39: 3765 { 3766 /** 0011 1001 bsr.w %a0 */ 3767 if (trace) 3768 { 3769 printf ("\033[33m%s\033[0m %02x\n", 3770 "/** 0011 1001 bsr.w %a0 */", 3771 op[0]); 3772 } 3773 SYNTAX("bsr.w %a0"); 3774 #line 797 "rx-decode.opc" 3775 ID(jsr); DC(pc + IMMex(2)); 3776 3777 } 3778 break; 3779 case 0x3a: 3780 case 0x3b: 3781 { 3782 /** 0011 101c b%1.w %a0 */ 3783 #line 771 "rx-decode.opc" 3784 int c AU = op[0] & 0x01; 3785 if (trace) 3786 { 3787 printf ("\033[33m%s\033[0m %02x\n", 3788 "/** 0011 101c b%1.w %a0 */", 3789 op[0]); 3790 printf (" c = 0x%x\n", c); 3791 } 3792 SYNTAX("b%1.w %a0"); 3793 #line 771 "rx-decode.opc" 3794 ID(branch); Scc(c); DC(pc + IMMex (2)); 3795 3796 3797 } 3798 break; 3799 case 0x3c: 3800 GETBYTE (); 3801 switch (op[1] & 0x00) 3802 { 3803 case 0x00: 3804 op_semantics_20: 3805 { 3806 /** 0011 11sz d dst sppp mov%s #%1, %0 */ 3807 #line 307 "rx-decode.opc" 3808 int sz AU = op[0] & 0x03; 3809 #line 307 "rx-decode.opc" 3810 int d AU = (op[1] >> 7) & 0x01; 3811 #line 307 "rx-decode.opc" 3812 int dst AU = (op[1] >> 4) & 0x07; 3813 #line 307 "rx-decode.opc" 3814 int sppp AU = op[1] & 0x0f; 3815 if (trace) 3816 { 3817 printf ("\033[33m%s\033[0m %02x %02x\n", 3818 "/** 0011 11sz d dst sppp mov%s #%1, %0 */", 3819 op[0], op[1]); 3820 printf (" sz = 0x%x,", sz); 3821 printf (" d = 0x%x,", d); 3822 printf (" dst = 0x%x,", dst); 3823 printf (" sppp = 0x%x\n", sppp); 3824 } 3825 SYNTAX("mov%s #%1, %0"); 3826 #line 307 "rx-decode.opc" 3827 ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F_____; 3828 3829 } 3830 break; 3831 } 3832 break; 3833 case 0x3d: 3834 GETBYTE (); 3835 switch (op[1] & 0x00) 3836 { 3837 case 0x00: 3838 goto op_semantics_20; 3839 break; 3840 } 3841 break; 3842 case 0x3e: 3843 GETBYTE (); 3844 switch (op[1] & 0x00) 3845 { 3846 case 0x00: 3847 goto op_semantics_20; 3848 break; 3849 } 3850 break; 3851 case 0x3f: 3852 GETBYTE (); 3853 switch (op[1] & 0x00) 3854 { 3855 case 0x00: 3856 { 3857 /** 0011 1111 rega regb rtsd #%1, %2-%0 */ 3858 #line 404 "rx-decode.opc" 3859 int rega AU = (op[1] >> 4) & 0x0f; 3860 #line 404 "rx-decode.opc" 3861 int regb AU = op[1] & 0x0f; 3862 if (trace) 3863 { 3864 printf ("\033[33m%s\033[0m %02x %02x\n", 3865 "/** 0011 1111 rega regb rtsd #%1, %2-%0 */", 3866 op[0], op[1]); 3867 printf (" rega = 0x%x,", rega); 3868 printf (" regb = 0x%x\n", regb); 3869 } 3870 SYNTAX("rtsd #%1, %2-%0"); 3871 #line 404 "rx-decode.opc" 3872 ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb); 3873 3874 /*----------------------------------------------------------------------*/ 3875 /* AND */ 3876 3877 } 3878 break; 3879 } 3880 break; 3881 case 0x40: 3882 GETBYTE (); 3883 switch (op[1] & 0x00) 3884 { 3885 case 0x00: 3886 op_semantics_21: 3887 { 3888 /** 0100 00ss rsrc rdst sub %2%S2, %1 */ 3889 #line 539 "rx-decode.opc" 3890 int ss AU = op[0] & 0x03; 3891 #line 539 "rx-decode.opc" 3892 int rsrc AU = (op[1] >> 4) & 0x0f; 3893 #line 539 "rx-decode.opc" 3894 int rdst AU = op[1] & 0x0f; 3895 if (trace) 3896 { 3897 printf ("\033[33m%s\033[0m %02x %02x\n", 3898 "/** 0100 00ss rsrc rdst sub %2%S2, %1 */", 3899 op[0], op[1]); 3900 printf (" ss = 0x%x,", ss); 3901 printf (" rsrc = 0x%x,", rsrc); 3902 printf (" rdst = 0x%x\n", rdst); 3903 } 3904 SYNTAX("sub %2%S2, %1"); 3905 #line 539 "rx-decode.opc" 3906 ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F_OSZC; 3907 3908 } 3909 break; 3910 } 3911 break; 3912 case 0x41: 3913 GETBYTE (); 3914 switch (op[1] & 0x00) 3915 { 3916 case 0x00: 3917 goto op_semantics_21; 3918 break; 3919 } 3920 break; 3921 case 0x42: 3922 GETBYTE (); 3923 switch (op[1] & 0x00) 3924 { 3925 case 0x00: 3926 goto op_semantics_21; 3927 break; 3928 } 3929 break; 3930 case 0x43: 3931 GETBYTE (); 3932 switch (op[1] & 0x00) 3933 { 3934 case 0x00: 3935 goto op_semantics_21; 3936 break; 3937 } 3938 break; 3939 case 0x44: 3940 GETBYTE (); 3941 switch (op[1] & 0x00) 3942 { 3943 case 0x00: 3944 op_semantics_22: 3945 { 3946 /** 0100 01ss rsrc rdst cmp %2%S2, %1 */ 3947 #line 527 "rx-decode.opc" 3948 int ss AU = op[0] & 0x03; 3949 #line 527 "rx-decode.opc" 3950 int rsrc AU = (op[1] >> 4) & 0x0f; 3951 #line 527 "rx-decode.opc" 3952 int rdst AU = op[1] & 0x0f; 3953 if (trace) 3954 { 3955 printf ("\033[33m%s\033[0m %02x %02x\n", 3956 "/** 0100 01ss rsrc rdst cmp %2%S2, %1 */", 3957 op[0], op[1]); 3958 printf (" ss = 0x%x,", ss); 3959 printf (" rsrc = 0x%x,", rsrc); 3960 printf (" rdst = 0x%x\n", rdst); 3961 } 3962 SYNTAX("cmp %2%S2, %1"); 3963 #line 527 "rx-decode.opc" 3964 ID(sub); S2P(ss, rsrc); SR(rdst); F_OSZC; 3965 3966 } 3967 break; 3968 } 3969 break; 3970 case 0x45: 3971 GETBYTE (); 3972 switch (op[1] & 0x00) 3973 { 3974 case 0x00: 3975 goto op_semantics_22; 3976 break; 3977 } 3978 break; 3979 case 0x46: 3980 GETBYTE (); 3981 switch (op[1] & 0x00) 3982 { 3983 case 0x00: 3984 goto op_semantics_22; 3985 break; 3986 } 3987 break; 3988 case 0x47: 3989 GETBYTE (); 3990 switch (op[1] & 0x00) 3991 { 3992 case 0x00: 3993 goto op_semantics_22; 3994 break; 3995 } 3996 break; 3997 case 0x48: 3998 GETBYTE (); 3999 switch (op[1] & 0x00) 4000 { 4001 case 0x00: 4002 op_semantics_23: 4003 { 4004 /** 0100 10ss rsrc rdst add %1%S1, %0 */ 4005 #line 503 "rx-decode.opc" 4006 int ss AU = op[0] & 0x03; 4007 #line 503 "rx-decode.opc" 4008 int rsrc AU = (op[1] >> 4) & 0x0f; 4009 #line 503 "rx-decode.opc" 4010 int rdst AU = op[1] & 0x0f; 4011 if (trace) 4012 { 4013 printf ("\033[33m%s\033[0m %02x %02x\n", 4014 "/** 0100 10ss rsrc rdst add %1%S1, %0 */", 4015 op[0], op[1]); 4016 printf (" ss = 0x%x,", ss); 4017 printf (" rsrc = 0x%x,", rsrc); 4018 printf (" rdst = 0x%x\n", rdst); 4019 } 4020 SYNTAX("add %1%S1, %0"); 4021 #line 503 "rx-decode.opc" 4022 ID(add); SP(ss, rsrc); DR(rdst); F_OSZC; 4023 4024 } 4025 break; 4026 } 4027 break; 4028 case 0x49: 4029 GETBYTE (); 4030 switch (op[1] & 0x00) 4031 { 4032 case 0x00: 4033 goto op_semantics_23; 4034 break; 4035 } 4036 break; 4037 case 0x4a: 4038 GETBYTE (); 4039 switch (op[1] & 0x00) 4040 { 4041 case 0x00: 4042 goto op_semantics_23; 4043 break; 4044 } 4045 break; 4046 case 0x4b: 4047 GETBYTE (); 4048 switch (op[1] & 0x00) 4049 { 4050 case 0x00: 4051 goto op_semantics_23; 4052 break; 4053 } 4054 break; 4055 case 0x4c: 4056 GETBYTE (); 4057 switch (op[1] & 0x00) 4058 { 4059 case 0x00: 4060 op_semantics_24: 4061 { 4062 /** 0100 11ss rsrc rdst mul %1%S1, %0 */ 4063 #line 646 "rx-decode.opc" 4064 int ss AU = op[0] & 0x03; 4065 #line 646 "rx-decode.opc" 4066 int rsrc AU = (op[1] >> 4) & 0x0f; 4067 #line 646 "rx-decode.opc" 4068 int rdst AU = op[1] & 0x0f; 4069 if (trace) 4070 { 4071 printf ("\033[33m%s\033[0m %02x %02x\n", 4072 "/** 0100 11ss rsrc rdst mul %1%S1, %0 */", 4073 op[0], op[1]); 4074 printf (" ss = 0x%x,", ss); 4075 printf (" rsrc = 0x%x,", rsrc); 4076 printf (" rdst = 0x%x\n", rdst); 4077 } 4078 SYNTAX("mul %1%S1, %0"); 4079 #line 646 "rx-decode.opc" 4080 ID(mul); SP(ss, rsrc); DR(rdst); F_____; 4081 4082 } 4083 break; 4084 } 4085 break; 4086 case 0x4d: 4087 GETBYTE (); 4088 switch (op[1] & 0x00) 4089 { 4090 case 0x00: 4091 goto op_semantics_24; 4092 break; 4093 } 4094 break; 4095 case 0x4e: 4096 GETBYTE (); 4097 switch (op[1] & 0x00) 4098 { 4099 case 0x00: 4100 goto op_semantics_24; 4101 break; 4102 } 4103 break; 4104 case 0x4f: 4105 GETBYTE (); 4106 switch (op[1] & 0x00) 4107 { 4108 case 0x00: 4109 goto op_semantics_24; 4110 break; 4111 } 4112 break; 4113 case 0x50: 4114 GETBYTE (); 4115 switch (op[1] & 0x00) 4116 { 4117 case 0x00: 4118 op_semantics_25: 4119 { 4120 /** 0101 00ss rsrc rdst and %1%S1, %0 */ 4121 #line 416 "rx-decode.opc" 4122 int ss AU = op[0] & 0x03; 4123 #line 416 "rx-decode.opc" 4124 int rsrc AU = (op[1] >> 4) & 0x0f; 4125 #line 416 "rx-decode.opc" 4126 int rdst AU = op[1] & 0x0f; 4127 if (trace) 4128 { 4129 printf ("\033[33m%s\033[0m %02x %02x\n", 4130 "/** 0101 00ss rsrc rdst and %1%S1, %0 */", 4131 op[0], op[1]); 4132 printf (" ss = 0x%x,", ss); 4133 printf (" rsrc = 0x%x,", rsrc); 4134 printf (" rdst = 0x%x\n", rdst); 4135 } 4136 SYNTAX("and %1%S1, %0"); 4137 #line 416 "rx-decode.opc" 4138 ID(and); SP(ss, rsrc); DR(rdst); F__SZ_; 4139 4140 } 4141 break; 4142 } 4143 break; 4144 case 0x51: 4145 GETBYTE (); 4146 switch (op[1] & 0x00) 4147 { 4148 case 0x00: 4149 goto op_semantics_25; 4150 break; 4151 } 4152 break; 4153 case 0x52: 4154 GETBYTE (); 4155 switch (op[1] & 0x00) 4156 { 4157 case 0x00: 4158 goto op_semantics_25; 4159 break; 4160 } 4161 break; 4162 case 0x53: 4163 GETBYTE (); 4164 switch (op[1] & 0x00) 4165 { 4166 case 0x00: 4167 goto op_semantics_25; 4168 break; 4169 } 4170 break; 4171 case 0x54: 4172 GETBYTE (); 4173 switch (op[1] & 0x00) 4174 { 4175 case 0x00: 4176 op_semantics_26: 4177 { 4178 /** 0101 01ss rsrc rdst or %1%S1, %0 */ 4179 #line 434 "rx-decode.opc" 4180 int ss AU = op[0] & 0x03; 4181 #line 434 "rx-decode.opc" 4182 int rsrc AU = (op[1] >> 4) & 0x0f; 4183 #line 434 "rx-decode.opc" 4184 int rdst AU = op[1] & 0x0f; 4185 if (trace) 4186 { 4187 printf ("\033[33m%s\033[0m %02x %02x\n", 4188 "/** 0101 01ss rsrc rdst or %1%S1, %0 */", 4189 op[0], op[1]); 4190 printf (" ss = 0x%x,", ss); 4191 printf (" rsrc = 0x%x,", rsrc); 4192 printf (" rdst = 0x%x\n", rdst); 4193 } 4194 SYNTAX("or %1%S1, %0"); 4195 #line 434 "rx-decode.opc" 4196 ID(or); SP(ss, rsrc); DR(rdst); F__SZ_; 4197 4198 } 4199 break; 4200 } 4201 break; 4202 case 0x55: 4203 GETBYTE (); 4204 switch (op[1] & 0x00) 4205 { 4206 case 0x00: 4207 goto op_semantics_26; 4208 break; 4209 } 4210 break; 4211 case 0x56: 4212 GETBYTE (); 4213 switch (op[1] & 0x00) 4214 { 4215 case 0x00: 4216 goto op_semantics_26; 4217 break; 4218 } 4219 break; 4220 case 0x57: 4221 GETBYTE (); 4222 switch (op[1] & 0x00) 4223 { 4224 case 0x00: 4225 goto op_semantics_26; 4226 break; 4227 } 4228 break; 4229 case 0x58: 4230 GETBYTE (); 4231 switch (op[1] & 0x00) 4232 { 4233 case 0x00: 4234 op_semantics_27: 4235 { 4236 /** 0101 1 s ss rsrc rdst movu%s %1, %0 */ 4237 #line 355 "rx-decode.opc" 4238 int s AU = (op[0] >> 2) & 0x01; 4239 #line 355 "rx-decode.opc" 4240 int ss AU = op[0] & 0x03; 4241 #line 355 "rx-decode.opc" 4242 int rsrc AU = (op[1] >> 4) & 0x0f; 4243 #line 355 "rx-decode.opc" 4244 int rdst AU = op[1] & 0x0f; 4245 if (trace) 4246 { 4247 printf ("\033[33m%s\033[0m %02x %02x\n", 4248 "/** 0101 1 s ss rsrc rdst movu%s %1, %0 */", 4249 op[0], op[1]); 4250 printf (" s = 0x%x,", s); 4251 printf (" ss = 0x%x,", ss); 4252 printf (" rsrc = 0x%x,", rsrc); 4253 printf (" rdst = 0x%x\n", rdst); 4254 } 4255 SYNTAX("movu%s %1, %0"); 4256 #line 355 "rx-decode.opc" 4257 ID(mov); uBW(s); SD(ss, rsrc, s); DR(rdst); F_____; 4258 4259 } 4260 break; 4261 } 4262 break; 4263 case 0x59: 4264 GETBYTE (); 4265 switch (op[1] & 0x00) 4266 { 4267 case 0x00: 4268 goto op_semantics_27; 4269 break; 4270 } 4271 break; 4272 case 0x5a: 4273 GETBYTE (); 4274 switch (op[1] & 0x00) 4275 { 4276 case 0x00: 4277 goto op_semantics_27; 4278 break; 4279 } 4280 break; 4281 case 0x5b: 4282 GETBYTE (); 4283 switch (op[1] & 0x00) 4284 { 4285 case 0x00: 4286 goto op_semantics_27; 4287 break; 4288 } 4289 break; 4290 case 0x5c: 4291 GETBYTE (); 4292 switch (op[1] & 0x00) 4293 { 4294 case 0x00: 4295 goto op_semantics_27; 4296 break; 4297 } 4298 break; 4299 case 0x5d: 4300 GETBYTE (); 4301 switch (op[1] & 0x00) 4302 { 4303 case 0x00: 4304 goto op_semantics_27; 4305 break; 4306 } 4307 break; 4308 case 0x5e: 4309 GETBYTE (); 4310 switch (op[1] & 0x00) 4311 { 4312 case 0x00: 4313 goto op_semantics_27; 4314 break; 4315 } 4316 break; 4317 case 0x5f: 4318 GETBYTE (); 4319 switch (op[1] & 0x00) 4320 { 4321 case 0x00: 4322 goto op_semantics_27; 4323 break; 4324 } 4325 break; 4326 case 0x60: 4327 GETBYTE (); 4328 switch (op[1] & 0x00) 4329 { 4330 case 0x00: 4331 { 4332 /** 0110 0000 immm rdst sub #%2, %0 */ 4333 #line 536 "rx-decode.opc" 4334 int immm AU = (op[1] >> 4) & 0x0f; 4335 #line 536 "rx-decode.opc" 4336 int rdst AU = op[1] & 0x0f; 4337 if (trace) 4338 { 4339 printf ("\033[33m%s\033[0m %02x %02x\n", 4340 "/** 0110 0000 immm rdst sub #%2, %0 */", 4341 op[0], op[1]); 4342 printf (" immm = 0x%x,", immm); 4343 printf (" rdst = 0x%x\n", rdst); 4344 } 4345 SYNTAX("sub #%2, %0"); 4346 #line 536 "rx-decode.opc" 4347 ID(sub); S2C(immm); SR(rdst); DR(rdst); F_OSZC; 4348 4349 } 4350 break; 4351 } 4352 break; 4353 case 0x61: 4354 GETBYTE (); 4355 switch (op[1] & 0x00) 4356 { 4357 case 0x00: 4358 { 4359 /** 0110 0001 immm rdst cmp #%2, %1 */ 4360 #line 518 "rx-decode.opc" 4361 int immm AU = (op[1] >> 4) & 0x0f; 4362 #line 518 "rx-decode.opc" 4363 int rdst AU = op[1] & 0x0f; 4364 if (trace) 4365 { 4366 printf ("\033[33m%s\033[0m %02x %02x\n", 4367 "/** 0110 0001 immm rdst cmp #%2, %1 */", 4368 op[0], op[1]); 4369 printf (" immm = 0x%x,", immm); 4370 printf (" rdst = 0x%x\n", rdst); 4371 } 4372 SYNTAX("cmp #%2, %1"); 4373 #line 518 "rx-decode.opc" 4374 ID(sub); S2C(immm); SR(rdst); F_OSZC; 4375 4376 } 4377 break; 4378 } 4379 break; 4380 case 0x62: 4381 GETBYTE (); 4382 switch (op[1] & 0x00) 4383 { 4384 case 0x00: 4385 { 4386 /** 0110 0010 immm rdst add #%1, %0 */ 4387 #line 500 "rx-decode.opc" 4388 int immm AU = (op[1] >> 4) & 0x0f; 4389 #line 500 "rx-decode.opc" 4390 int rdst AU = op[1] & 0x0f; 4391 if (trace) 4392 { 4393 printf ("\033[33m%s\033[0m %02x %02x\n", 4394 "/** 0110 0010 immm rdst add #%1, %0 */", 4395 op[0], op[1]); 4396 printf (" immm = 0x%x,", immm); 4397 printf (" rdst = 0x%x\n", rdst); 4398 } 4399 SYNTAX("add #%1, %0"); 4400 #line 500 "rx-decode.opc" 4401 ID(add); SC(immm); DR(rdst); F_OSZC; 4402 4403 } 4404 break; 4405 } 4406 break; 4407 case 0x63: 4408 GETBYTE (); 4409 switch (op[1] & 0x00) 4410 { 4411 case 0x00: 4412 { 4413 /** 0110 0011 immm rdst mul #%1, %0 */ 4414 #line 612 "rx-decode.opc" 4415 int immm AU = (op[1] >> 4) & 0x0f; 4416 #line 612 "rx-decode.opc" 4417 int rdst AU = op[1] & 0x0f; 4418 if (trace) 4419 { 4420 printf ("\033[33m%s\033[0m %02x %02x\n", 4421 "/** 0110 0011 immm rdst mul #%1, %0 */", 4422 op[0], op[1]); 4423 printf (" immm = 0x%x,", immm); 4424 printf (" rdst = 0x%x\n", rdst); 4425 } 4426 SYNTAX("mul #%1, %0"); 4427 #line 612 "rx-decode.opc" 4428 if (immm == 1 && rdst == 0) 4429 { 4430 ID(nop2); 4431 SYNTAX ("nop\t; mul\t#1, r0"); 4432 } 4433 else 4434 { 4435 ID(mul); 4436 } 4437 DR(rdst); SC(immm); F_____; 4438 4439 } 4440 break; 4441 } 4442 break; 4443 case 0x64: 4444 GETBYTE (); 4445 switch (op[1] & 0x00) 4446 { 4447 case 0x00: 4448 { 4449 /** 0110 0100 immm rdst and #%1, %0 */ 4450 #line 410 "rx-decode.opc" 4451 int immm AU = (op[1] >> 4) & 0x0f; 4452 #line 410 "rx-decode.opc" 4453 int rdst AU = op[1] & 0x0f; 4454 if (trace) 4455 { 4456 printf ("\033[33m%s\033[0m %02x %02x\n", 4457 "/** 0110 0100 immm rdst and #%1, %0 */", 4458 op[0], op[1]); 4459 printf (" immm = 0x%x,", immm); 4460 printf (" rdst = 0x%x\n", rdst); 4461 } 4462 SYNTAX("and #%1, %0"); 4463 #line 410 "rx-decode.opc" 4464 ID(and); SC(immm); DR(rdst); F__SZ_; 4465 4466 } 4467 break; 4468 } 4469 break; 4470 case 0x65: 4471 GETBYTE (); 4472 switch (op[1] & 0x00) 4473 { 4474 case 0x00: 4475 { 4476 /** 0110 0101 immm rdst or #%1, %0 */ 4477 #line 428 "rx-decode.opc" 4478 int immm AU = (op[1] >> 4) & 0x0f; 4479 #line 428 "rx-decode.opc" 4480 int rdst AU = op[1] & 0x0f; 4481 if (trace) 4482 { 4483 printf ("\033[33m%s\033[0m %02x %02x\n", 4484 "/** 0110 0101 immm rdst or #%1, %0 */", 4485 op[0], op[1]); 4486 printf (" immm = 0x%x,", immm); 4487 printf (" rdst = 0x%x\n", rdst); 4488 } 4489 SYNTAX("or #%1, %0"); 4490 #line 428 "rx-decode.opc" 4491 ID(or); SC(immm); DR(rdst); F__SZ_; 4492 4493 } 4494 break; 4495 } 4496 break; 4497 case 0x66: 4498 GETBYTE (); 4499 switch (op[1] & 0x00) 4500 { 4501 case 0x00: 4502 { 4503 /** 0110 0110 immm rdst mov%s #%1, %0 */ 4504 #line 304 "rx-decode.opc" 4505 int immm AU = (op[1] >> 4) & 0x0f; 4506 #line 304 "rx-decode.opc" 4507 int rdst AU = op[1] & 0x0f; 4508 if (trace) 4509 { 4510 printf ("\033[33m%s\033[0m %02x %02x\n", 4511 "/** 0110 0110 immm rdst mov%s #%1, %0 */", 4512 op[0], op[1]); 4513 printf (" immm = 0x%x,", immm); 4514 printf (" rdst = 0x%x\n", rdst); 4515 } 4516 SYNTAX("mov%s #%1, %0"); 4517 #line 304 "rx-decode.opc" 4518 ID(mov); DR(rdst); SC(immm); F_____; 4519 4520 } 4521 break; 4522 } 4523 break; 4524 case 0x67: 4525 { 4526 /** 0110 0111 rtsd #%1 */ 4527 if (trace) 4528 { 4529 printf ("\033[33m%s\033[0m %02x\n", 4530 "/** 0110 0111 rtsd #%1 */", 4531 op[0]); 4532 } 4533 SYNTAX("rtsd #%1"); 4534 #line 401 "rx-decode.opc" 4535 ID(rtsd); SC(IMM(1) * 4); 4536 4537 } 4538 break; 4539 case 0x68: 4540 GETBYTE (); 4541 switch (op[1] & 0x00) 4542 { 4543 case 0x00: 4544 op_semantics_28: 4545 { 4546 /** 0110 100i mmmm rdst shlr #%2, %0 */ 4547 #line 726 "rx-decode.opc" 4548 int i AU = op[0] & 0x01; 4549 #line 726 "rx-decode.opc" 4550 int mmmm AU = (op[1] >> 4) & 0x0f; 4551 #line 726 "rx-decode.opc" 4552 int rdst AU = op[1] & 0x0f; 4553 if (trace) 4554 { 4555 printf ("\033[33m%s\033[0m %02x %02x\n", 4556 "/** 0110 100i mmmm rdst shlr #%2, %0 */", 4557 op[0], op[1]); 4558 printf (" i = 0x%x,", i); 4559 printf (" mmmm = 0x%x,", mmmm); 4560 printf (" rdst = 0x%x\n", rdst); 4561 } 4562 SYNTAX("shlr #%2, %0"); 4563 #line 726 "rx-decode.opc" 4564 ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F__SZC; 4565 4566 } 4567 break; 4568 } 4569 break; 4570 case 0x69: 4571 GETBYTE (); 4572 switch (op[1] & 0x00) 4573 { 4574 case 0x00: 4575 goto op_semantics_28; 4576 break; 4577 } 4578 break; 4579 case 0x6a: 4580 GETBYTE (); 4581 switch (op[1] & 0x00) 4582 { 4583 case 0x00: 4584 op_semantics_29: 4585 { 4586 /** 0110 101i mmmm rdst shar #%2, %0 */ 4587 #line 716 "rx-decode.opc" 4588 int i AU = op[0] & 0x01; 4589 #line 716 "rx-decode.opc" 4590 int mmmm AU = (op[1] >> 4) & 0x0f; 4591 #line 716 "rx-decode.opc" 4592 int rdst AU = op[1] & 0x0f; 4593 if (trace) 4594 { 4595 printf ("\033[33m%s\033[0m %02x %02x\n", 4596 "/** 0110 101i mmmm rdst shar #%2, %0 */", 4597 op[0], op[1]); 4598 printf (" i = 0x%x,", i); 4599 printf (" mmmm = 0x%x,", mmmm); 4600 printf (" rdst = 0x%x\n", rdst); 4601 } 4602 SYNTAX("shar #%2, %0"); 4603 #line 716 "rx-decode.opc" 4604 ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_0SZC; 4605 4606 } 4607 break; 4608 } 4609 break; 4610 case 0x6b: 4611 GETBYTE (); 4612 switch (op[1] & 0x00) 4613 { 4614 case 0x00: 4615 goto op_semantics_29; 4616 break; 4617 } 4618 break; 4619 case 0x6c: 4620 GETBYTE (); 4621 switch (op[1] & 0x00) 4622 { 4623 case 0x00: 4624 op_semantics_30: 4625 { 4626 /** 0110 110i mmmm rdst shll #%2, %0 */ 4627 #line 706 "rx-decode.opc" 4628 int i AU = op[0] & 0x01; 4629 #line 706 "rx-decode.opc" 4630 int mmmm AU = (op[1] >> 4) & 0x0f; 4631 #line 706 "rx-decode.opc" 4632 int rdst AU = op[1] & 0x0f; 4633 if (trace) 4634 { 4635 printf ("\033[33m%s\033[0m %02x %02x\n", 4636 "/** 0110 110i mmmm rdst shll #%2, %0 */", 4637 op[0], op[1]); 4638 printf (" i = 0x%x,", i); 4639 printf (" mmmm = 0x%x,", mmmm); 4640 printf (" rdst = 0x%x\n", rdst); 4641 } 4642 SYNTAX("shll #%2, %0"); 4643 #line 706 "rx-decode.opc" 4644 ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_OSZC; 4645 4646 } 4647 break; 4648 } 4649 break; 4650 case 0x6d: 4651 GETBYTE (); 4652 switch (op[1] & 0x00) 4653 { 4654 case 0x00: 4655 goto op_semantics_30; 4656 break; 4657 } 4658 break; 4659 case 0x6e: 4660 GETBYTE (); 4661 switch (op[1] & 0x00) 4662 { 4663 case 0x00: 4664 { 4665 /** 0110 1110 dsta dstb pushm %1-%2 */ 4666 #line 368 "rx-decode.opc" 4667 int dsta AU = (op[1] >> 4) & 0x0f; 4668 #line 368 "rx-decode.opc" 4669 int dstb AU = op[1] & 0x0f; 4670 if (trace) 4671 { 4672 printf ("\033[33m%s\033[0m %02x %02x\n", 4673 "/** 0110 1110 dsta dstb pushm %1-%2 */", 4674 op[0], op[1]); 4675 printf (" dsta = 0x%x,", dsta); 4676 printf (" dstb = 0x%x\n", dstb); 4677 } 4678 SYNTAX("pushm %1-%2"); 4679 #line 368 "rx-decode.opc" 4680 ID(pushm); SR(dsta); S2R(dstb); F_____; 4681 4682 } 4683 break; 4684 } 4685 break; 4686 case 0x6f: 4687 GETBYTE (); 4688 switch (op[1] & 0x00) 4689 { 4690 case 0x00: 4691 { 4692 /** 0110 1111 dsta dstb popm %1-%2 */ 4693 #line 365 "rx-decode.opc" 4694 int dsta AU = (op[1] >> 4) & 0x0f; 4695 #line 365 "rx-decode.opc" 4696 int dstb AU = op[1] & 0x0f; 4697 if (trace) 4698 { 4699 printf ("\033[33m%s\033[0m %02x %02x\n", 4700 "/** 0110 1111 dsta dstb popm %1-%2 */", 4701 op[0], op[1]); 4702 printf (" dsta = 0x%x,", dsta); 4703 printf (" dstb = 0x%x\n", dstb); 4704 } 4705 SYNTAX("popm %1-%2"); 4706 #line 365 "rx-decode.opc" 4707 ID(popm); SR(dsta); S2R(dstb); F_____; 4708 4709 } 4710 break; 4711 } 4712 break; 4713 case 0x70: 4714 GETBYTE (); 4715 switch (op[1] & 0x00) 4716 { 4717 case 0x00: 4718 op_semantics_31: 4719 { 4720 /** 0111 00im rsrc rdst add #%1, %2, %0 */ 4721 #line 509 "rx-decode.opc" 4722 int im AU = op[0] & 0x03; 4723 #line 509 "rx-decode.opc" 4724 int rsrc AU = (op[1] >> 4) & 0x0f; 4725 #line 509 "rx-decode.opc" 4726 int rdst AU = op[1] & 0x0f; 4727 if (trace) 4728 { 4729 printf ("\033[33m%s\033[0m %02x %02x\n", 4730 "/** 0111 00im rsrc rdst add #%1, %2, %0 */", 4731 op[0], op[1]); 4732 printf (" im = 0x%x,", im); 4733 printf (" rsrc = 0x%x,", rsrc); 4734 printf (" rdst = 0x%x\n", rdst); 4735 } 4736 SYNTAX("add #%1, %2, %0"); 4737 #line 509 "rx-decode.opc" 4738 ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F_OSZC; 4739 4740 } 4741 break; 4742 } 4743 break; 4744 case 0x71: 4745 GETBYTE (); 4746 switch (op[1] & 0x00) 4747 { 4748 case 0x00: 4749 goto op_semantics_31; 4750 break; 4751 } 4752 break; 4753 case 0x72: 4754 GETBYTE (); 4755 switch (op[1] & 0x00) 4756 { 4757 case 0x00: 4758 goto op_semantics_31; 4759 break; 4760 } 4761 break; 4762 case 0x73: 4763 GETBYTE (); 4764 switch (op[1] & 0x00) 4765 { 4766 case 0x00: 4767 goto op_semantics_31; 4768 break; 4769 } 4770 break; 4771 case 0x74: 4772 GETBYTE (); 4773 switch (op[1] & 0xf0) 4774 { 4775 case 0x00: 4776 op_semantics_32: 4777 { 4778 /** 0111 01im 0000 rsrc cmp #%2, %1%S1 */ 4779 #line 521 "rx-decode.opc" 4780 int im AU = op[0] & 0x03; 4781 #line 521 "rx-decode.opc" 4782 int rsrc AU = op[1] & 0x0f; 4783 if (trace) 4784 { 4785 printf ("\033[33m%s\033[0m %02x %02x\n", 4786 "/** 0111 01im 0000 rsrc cmp #%2, %1%S1 */", 4787 op[0], op[1]); 4788 printf (" im = 0x%x,", im); 4789 printf (" rsrc = 0x%x\n", rsrc); 4790 } 4791 SYNTAX("cmp #%2, %1%S1"); 4792 #line 521 "rx-decode.opc" 4793 ID(sub); SR(rsrc); S2C(IMMex(im)); F_OSZC; 4794 4795 } 4796 break; 4797 case 0x10: 4798 op_semantics_33: 4799 { 4800 /** 0111 01im 0001rdst mul #%1, %0 */ 4801 #line 624 "rx-decode.opc" 4802 int im AU = op[0] & 0x03; 4803 #line 624 "rx-decode.opc" 4804 int rdst AU = op[1] & 0x0f; 4805 if (trace) 4806 { 4807 printf ("\033[33m%s\033[0m %02x %02x\n", 4808 "/** 0111 01im 0001rdst mul #%1, %0 */", 4809 op[0], op[1]); 4810 printf (" im = 0x%x,", im); 4811 printf (" rdst = 0x%x\n", rdst); 4812 } 4813 SYNTAX("mul #%1, %0"); 4814 #line 624 "rx-decode.opc" 4815 int val = IMMex(im); 4816 if (val == 1 && rdst == 0) 4817 { 4818 SYNTAX("nop\t; mul\t#1, r0"); 4819 switch (im) 4820 { 4821 case 2: ID(nop4); break; 4822 case 3: ID(nop5); break; 4823 case 0: ID(nop6); break; 4824 default: 4825 ID(mul); 4826 SYNTAX("mul #%1, %0"); 4827 break; 4828 } 4829 } 4830 else 4831 { 4832 ID(mul); 4833 } 4834 DR(rdst); SC(val); F_____; 4835 4836 } 4837 break; 4838 case 0x20: 4839 op_semantics_34: 4840 { 4841 /** 0111 01im 0010 rdst and #%1, %0 */ 4842 #line 413 "rx-decode.opc" 4843 int im AU = op[0] & 0x03; 4844 #line 413 "rx-decode.opc" 4845 int rdst AU = op[1] & 0x0f; 4846 if (trace) 4847 { 4848 printf ("\033[33m%s\033[0m %02x %02x\n", 4849 "/** 0111 01im 0010 rdst and #%1, %0 */", 4850 op[0], op[1]); 4851 printf (" im = 0x%x,", im); 4852 printf (" rdst = 0x%x\n", rdst); 4853 } 4854 SYNTAX("and #%1, %0"); 4855 #line 413 "rx-decode.opc" 4856 ID(and); SC(IMMex(im)); DR(rdst); F__SZ_; 4857 4858 } 4859 break; 4860 case 0x30: 4861 op_semantics_35: 4862 { 4863 /** 0111 01im 0011 rdst or #%1, %0 */ 4864 #line 431 "rx-decode.opc" 4865 int im AU = op[0] & 0x03; 4866 #line 431 "rx-decode.opc" 4867 int rdst AU = op[1] & 0x0f; 4868 if (trace) 4869 { 4870 printf ("\033[33m%s\033[0m %02x %02x\n", 4871 "/** 0111 01im 0011 rdst or #%1, %0 */", 4872 op[0], op[1]); 4873 printf (" im = 0x%x,", im); 4874 printf (" rdst = 0x%x\n", rdst); 4875 } 4876 SYNTAX("or #%1, %0"); 4877 #line 431 "rx-decode.opc" 4878 ID(or); SC(IMMex(im)); DR(rdst); F__SZ_; 4879 4880 } 4881 break; 4882 default: UNSUPPORTED(); break; 4883 } 4884 break; 4885 case 0x75: 4886 GETBYTE (); 4887 switch (op[1] & 0xff) 4888 { 4889 case 0x00: 4890 case 0x01: 4891 case 0x02: 4892 case 0x03: 4893 case 0x04: 4894 case 0x05: 4895 case 0x06: 4896 case 0x07: 4897 case 0x08: 4898 case 0x09: 4899 case 0x0a: 4900 case 0x0b: 4901 case 0x0c: 4902 case 0x0d: 4903 case 0x0e: 4904 case 0x0f: 4905 goto op_semantics_32; 4906 break; 4907 case 0x10: 4908 case 0x11: 4909 case 0x12: 4910 case 0x13: 4911 case 0x14: 4912 case 0x15: 4913 case 0x16: 4914 case 0x17: 4915 case 0x18: 4916 case 0x19: 4917 case 0x1a: 4918 case 0x1b: 4919 case 0x1c: 4920 case 0x1d: 4921 case 0x1e: 4922 case 0x1f: 4923 goto op_semantics_33; 4924 break; 4925 case 0x20: 4926 case 0x21: 4927 case 0x22: 4928 case 0x23: 4929 case 0x24: 4930 case 0x25: 4931 case 0x26: 4932 case 0x27: 4933 case 0x28: 4934 case 0x29: 4935 case 0x2a: 4936 case 0x2b: 4937 case 0x2c: 4938 case 0x2d: 4939 case 0x2e: 4940 case 0x2f: 4941 goto op_semantics_34; 4942 break; 4943 case 0x30: 4944 case 0x31: 4945 case 0x32: 4946 case 0x33: 4947 case 0x34: 4948 case 0x35: 4949 case 0x36: 4950 case 0x37: 4951 case 0x38: 4952 case 0x39: 4953 case 0x3a: 4954 case 0x3b: 4955 case 0x3c: 4956 case 0x3d: 4957 case 0x3e: 4958 case 0x3f: 4959 goto op_semantics_35; 4960 break; 4961 case 0x40: 4962 case 0x41: 4963 case 0x42: 4964 case 0x43: 4965 case 0x44: 4966 case 0x45: 4967 case 0x46: 4968 case 0x47: 4969 case 0x48: 4970 case 0x49: 4971 case 0x4a: 4972 case 0x4b: 4973 case 0x4c: 4974 case 0x4d: 4975 case 0x4e: 4976 case 0x4f: 4977 { 4978 /** 0111 0101 0100 rdst mov%s #%1, %0 */ 4979 #line 285 "rx-decode.opc" 4980 int rdst AU = op[1] & 0x0f; 4981 if (trace) 4982 { 4983 printf ("\033[33m%s\033[0m %02x %02x\n", 4984 "/** 0111 0101 0100 rdst mov%s #%1, %0 */", 4985 op[0], op[1]); 4986 printf (" rdst = 0x%x\n", rdst); 4987 } 4988 SYNTAX("mov%s #%1, %0"); 4989 #line 285 "rx-decode.opc" 4990 ID(mov); DR(rdst); SC(IMM (1)); F_____; 4991 4992 } 4993 break; 4994 case 0x50: 4995 case 0x51: 4996 case 0x52: 4997 case 0x53: 4998 case 0x54: 4999 case 0x55: 5000 case 0x56: 5001 case 0x57: 5002 case 0x58: 5003 case 0x59: 5004 case 0x5a: 5005 case 0x5b: 5006 case 0x5c: 5007 case 0x5d: 5008 case 0x5e: 5009 case 0x5f: 5010 { 5011 /** 0111 0101 0101 rsrc cmp #%2, %1 */ 5012 #line 524 "rx-decode.opc" 5013 int rsrc AU = op[1] & 0x0f; 5014 if (trace) 5015 { 5016 printf ("\033[33m%s\033[0m %02x %02x\n", 5017 "/** 0111 0101 0101 rsrc cmp #%2, %1 */", 5018 op[0], op[1]); 5019 printf (" rsrc = 0x%x\n", rsrc); 5020 } 5021 SYNTAX("cmp #%2, %1"); 5022 #line 524 "rx-decode.opc" 5023 ID(sub); SR(rsrc); S2C(IMM(1)); F_OSZC; 5024 5025 } 5026 break; 5027 case 0x60: 5028 { 5029 /** 0111 0101 0110 0000 int #%1 */ 5030 if (trace) 5031 { 5032 printf ("\033[33m%s\033[0m %02x %02x\n", 5033 "/** 0111 0101 0110 0000 int #%1 */", 5034 op[0], op[1]); 5035 } 5036 SYNTAX("int #%1"); 5037 #line 1031 "rx-decode.opc" 5038 ID(int); SC(IMM(1)); 5039 5040 } 5041 break; 5042 case 0x70: 5043 GETBYTE (); 5044 switch (op[2] & 0xf0) 5045 { 5046 case 0x00: 5047 { 5048 /** 0111 0101 0111 0000 0000 immm mvtipl #%1 */ 5049 #line 998 "rx-decode.opc" 5050 int immm AU = op[2] & 0x0f; 5051 if (trace) 5052 { 5053 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 5054 "/** 0111 0101 0111 0000 0000 immm mvtipl #%1 */", 5055 op[0], op[1], op[2]); 5056 printf (" immm = 0x%x\n", immm); 5057 } 5058 SYNTAX("mvtipl #%1"); 5059 #line 998 "rx-decode.opc" 5060 ID(mvtipl); SC(immm); 5061 5062 } 5063 break; 5064 default: UNSUPPORTED(); break; 5065 } 5066 break; 5067 default: UNSUPPORTED(); break; 5068 } 5069 break; 5070 case 0x76: 5071 GETBYTE (); 5072 switch (op[1] & 0xf0) 5073 { 5074 case 0x00: 5075 goto op_semantics_32; 5076 break; 5077 case 0x10: 5078 goto op_semantics_33; 5079 break; 5080 case 0x20: 5081 goto op_semantics_34; 5082 break; 5083 case 0x30: 5084 goto op_semantics_35; 5085 break; 5086 default: UNSUPPORTED(); break; 5087 } 5088 break; 5089 case 0x77: 5090 GETBYTE (); 5091 switch (op[1] & 0xf0) 5092 { 5093 case 0x00: 5094 goto op_semantics_32; 5095 break; 5096 case 0x10: 5097 goto op_semantics_33; 5098 break; 5099 case 0x20: 5100 goto op_semantics_34; 5101 break; 5102 case 0x30: 5103 goto op_semantics_35; 5104 break; 5105 default: UNSUPPORTED(); break; 5106 } 5107 break; 5108 case 0x78: 5109 GETBYTE (); 5110 switch (op[1] & 0x00) 5111 { 5112 case 0x00: 5113 op_semantics_36: 5114 { 5115 /** 0111 100b ittt rdst bset #%1, %0 */ 5116 #line 943 "rx-decode.opc" 5117 int b AU = op[0] & 0x01; 5118 #line 943 "rx-decode.opc" 5119 int ittt AU = (op[1] >> 4) & 0x0f; 5120 #line 943 "rx-decode.opc" 5121 int rdst AU = op[1] & 0x0f; 5122 if (trace) 5123 { 5124 printf ("\033[33m%s\033[0m %02x %02x\n", 5125 "/** 0111 100b ittt rdst bset #%1, %0 */", 5126 op[0], op[1]); 5127 printf (" b = 0x%x,", b); 5128 printf (" ittt = 0x%x,", ittt); 5129 printf (" rdst = 0x%x\n", rdst); 5130 } 5131 SYNTAX("bset #%1, %0"); 5132 #line 943 "rx-decode.opc" 5133 ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____; 5134 5135 5136 } 5137 break; 5138 } 5139 break; 5140 case 0x79: 5141 GETBYTE (); 5142 switch (op[1] & 0x00) 5143 { 5144 case 0x00: 5145 goto op_semantics_36; 5146 break; 5147 } 5148 break; 5149 case 0x7a: 5150 GETBYTE (); 5151 switch (op[1] & 0x00) 5152 { 5153 case 0x00: 5154 op_semantics_37: 5155 { 5156 /** 0111 101b ittt rdst bclr #%1, %0 */ 5157 #line 955 "rx-decode.opc" 5158 int b AU = op[0] & 0x01; 5159 #line 955 "rx-decode.opc" 5160 int ittt AU = (op[1] >> 4) & 0x0f; 5161 #line 955 "rx-decode.opc" 5162 int rdst AU = op[1] & 0x0f; 5163 if (trace) 5164 { 5165 printf ("\033[33m%s\033[0m %02x %02x\n", 5166 "/** 0111 101b ittt rdst bclr #%1, %0 */", 5167 op[0], op[1]); 5168 printf (" b = 0x%x,", b); 5169 printf (" ittt = 0x%x,", ittt); 5170 printf (" rdst = 0x%x\n", rdst); 5171 } 5172 SYNTAX("bclr #%1, %0"); 5173 #line 955 "rx-decode.opc" 5174 ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____; 5175 5176 5177 } 5178 break; 5179 } 5180 break; 5181 case 0x7b: 5182 GETBYTE (); 5183 switch (op[1] & 0x00) 5184 { 5185 case 0x00: 5186 goto op_semantics_37; 5187 break; 5188 } 5189 break; 5190 case 0x7c: 5191 GETBYTE (); 5192 switch (op[1] & 0x00) 5193 { 5194 case 0x00: 5195 op_semantics_38: 5196 { 5197 /** 0111 110b ittt rdst btst #%2, %1 */ 5198 #line 967 "rx-decode.opc" 5199 int b AU = op[0] & 0x01; 5200 #line 967 "rx-decode.opc" 5201 int ittt AU = (op[1] >> 4) & 0x0f; 5202 #line 967 "rx-decode.opc" 5203 int rdst AU = op[1] & 0x0f; 5204 if (trace) 5205 { 5206 printf ("\033[33m%s\033[0m %02x %02x\n", 5207 "/** 0111 110b ittt rdst btst #%2, %1 */", 5208 op[0], op[1]); 5209 printf (" b = 0x%x,", b); 5210 printf (" ittt = 0x%x,", ittt); 5211 printf (" rdst = 0x%x\n", rdst); 5212 } 5213 SYNTAX("btst #%2, %1"); 5214 #line 967 "rx-decode.opc" 5215 ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F___ZC; 5216 5217 5218 } 5219 break; 5220 } 5221 break; 5222 case 0x7d: 5223 GETBYTE (); 5224 switch (op[1] & 0x00) 5225 { 5226 case 0x00: 5227 goto op_semantics_38; 5228 break; 5229 } 5230 break; 5231 case 0x7e: 5232 GETBYTE (); 5233 switch (op[1] & 0xf0) 5234 { 5235 case 0x00: 5236 { 5237 /** 0111 1110 0000 rdst not %0 */ 5238 #line 458 "rx-decode.opc" 5239 int rdst AU = op[1] & 0x0f; 5240 if (trace) 5241 { 5242 printf ("\033[33m%s\033[0m %02x %02x\n", 5243 "/** 0111 1110 0000 rdst not %0 */", 5244 op[0], op[1]); 5245 printf (" rdst = 0x%x\n", rdst); 5246 } 5247 SYNTAX("not %0"); 5248 #line 458 "rx-decode.opc" 5249 ID(xor); DR(rdst); SR(rdst); S2C(~0); F__SZ_; 5250 5251 } 5252 break; 5253 case 0x10: 5254 { 5255 /** 0111 1110 0001 rdst neg %0 */ 5256 #line 479 "rx-decode.opc" 5257 int rdst AU = op[1] & 0x0f; 5258 if (trace) 5259 { 5260 printf ("\033[33m%s\033[0m %02x %02x\n", 5261 "/** 0111 1110 0001 rdst neg %0 */", 5262 op[0], op[1]); 5263 printf (" rdst = 0x%x\n", rdst); 5264 } 5265 SYNTAX("neg %0"); 5266 #line 479 "rx-decode.opc" 5267 ID(sub); DR(rdst); SC(0); S2R(rdst); F_OSZC; 5268 5269 } 5270 break; 5271 case 0x20: 5272 { 5273 /** 0111 1110 0010 rdst abs %0 */ 5274 #line 561 "rx-decode.opc" 5275 int rdst AU = op[1] & 0x0f; 5276 if (trace) 5277 { 5278 printf ("\033[33m%s\033[0m %02x %02x\n", 5279 "/** 0111 1110 0010 rdst abs %0 */", 5280 op[0], op[1]); 5281 printf (" rdst = 0x%x\n", rdst); 5282 } 5283 SYNTAX("abs %0"); 5284 #line 561 "rx-decode.opc" 5285 ID(abs); DR(rdst); SR(rdst); F_OSZ_; 5286 5287 } 5288 break; 5289 case 0x30: 5290 { 5291 /** 0111 1110 0011 rdst sat %0 */ 5292 #line 881 "rx-decode.opc" 5293 int rdst AU = op[1] & 0x0f; 5294 if (trace) 5295 { 5296 printf ("\033[33m%s\033[0m %02x %02x\n", 5297 "/** 0111 1110 0011 rdst sat %0 */", 5298 op[0], op[1]); 5299 printf (" rdst = 0x%x\n", rdst); 5300 } 5301 SYNTAX("sat %0"); 5302 #line 881 "rx-decode.opc" 5303 ID(sat); DR (rdst); 5304 5305 } 5306 break; 5307 case 0x40: 5308 { 5309 /** 0111 1110 0100 rdst rorc %0 */ 5310 #line 741 "rx-decode.opc" 5311 int rdst AU = op[1] & 0x0f; 5312 if (trace) 5313 { 5314 printf ("\033[33m%s\033[0m %02x %02x\n", 5315 "/** 0111 1110 0100 rdst rorc %0 */", 5316 op[0], op[1]); 5317 printf (" rdst = 0x%x\n", rdst); 5318 } 5319 SYNTAX("rorc %0"); 5320 #line 741 "rx-decode.opc" 5321 ID(rorc); DR(rdst); F__SZC; 5322 5323 } 5324 break; 5325 case 0x50: 5326 { 5327 /** 0111 1110 0101 rdst rolc %0 */ 5328 #line 738 "rx-decode.opc" 5329 int rdst AU = op[1] & 0x0f; 5330 if (trace) 5331 { 5332 printf ("\033[33m%s\033[0m %02x %02x\n", 5333 "/** 0111 1110 0101 rdst rolc %0 */", 5334 op[0], op[1]); 5335 printf (" rdst = 0x%x\n", rdst); 5336 } 5337 SYNTAX("rolc %0"); 5338 #line 738 "rx-decode.opc" 5339 ID(rolc); DR(rdst); F__SZC; 5340 5341 } 5342 break; 5343 case 0x80: 5344 case 0x90: 5345 case 0xa0: 5346 { 5347 /** 0111 1110 10sz rsrc push%s %1 */ 5348 #line 374 "rx-decode.opc" 5349 int sz AU = (op[1] >> 4) & 0x03; 5350 #line 374 "rx-decode.opc" 5351 int rsrc AU = op[1] & 0x0f; 5352 if (trace) 5353 { 5354 printf ("\033[33m%s\033[0m %02x %02x\n", 5355 "/** 0111 1110 10sz rsrc push%s %1 */", 5356 op[0], op[1]); 5357 printf (" sz = 0x%x,", sz); 5358 printf (" rsrc = 0x%x\n", rsrc); 5359 } 5360 SYNTAX("push%s %1"); 5361 #line 374 "rx-decode.opc" 5362 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F_____; 5363 5364 } 5365 break; 5366 case 0xb0: 5367 { 5368 /** 0111 1110 1011 rdst pop %0 */ 5369 #line 371 "rx-decode.opc" 5370 int rdst AU = op[1] & 0x0f; 5371 if (trace) 5372 { 5373 printf ("\033[33m%s\033[0m %02x %02x\n", 5374 "/** 0111 1110 1011 rdst pop %0 */", 5375 op[0], op[1]); 5376 printf (" rdst = 0x%x\n", rdst); 5377 } 5378 SYNTAX("pop %0"); 5379 #line 371 "rx-decode.opc" 5380 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F_____; 5381 5382 } 5383 break; 5384 case 0xc0: 5385 case 0xd0: 5386 { 5387 /** 0111 1110 110 crsrc pushc %1 */ 5388 #line 1004 "rx-decode.opc" 5389 int crsrc AU = op[1] & 0x1f; 5390 if (trace) 5391 { 5392 printf ("\033[33m%s\033[0m %02x %02x\n", 5393 "/** 0111 1110 110 crsrc pushc %1 */", 5394 op[0], op[1]); 5395 printf (" crsrc = 0x%x\n", crsrc); 5396 } 5397 SYNTAX("pushc %1"); 5398 #line 1004 "rx-decode.opc" 5399 ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16); 5400 5401 } 5402 break; 5403 case 0xe0: 5404 case 0xf0: 5405 { 5406 /** 0111 1110 111 crdst popc %0 */ 5407 #line 1001 "rx-decode.opc" 5408 int crdst AU = op[1] & 0x1f; 5409 if (trace) 5410 { 5411 printf ("\033[33m%s\033[0m %02x %02x\n", 5412 "/** 0111 1110 111 crdst popc %0 */", 5413 op[0], op[1]); 5414 printf (" crdst = 0x%x\n", crdst); 5415 } 5416 SYNTAX("popc %0"); 5417 #line 1001 "rx-decode.opc" 5418 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16); 5419 5420 } 5421 break; 5422 default: UNSUPPORTED(); break; 5423 } 5424 break; 5425 case 0x7f: 5426 GETBYTE (); 5427 switch (op[1] & 0xff) 5428 { 5429 case 0x00: 5430 case 0x01: 5431 case 0x02: 5432 case 0x03: 5433 case 0x04: 5434 case 0x05: 5435 case 0x06: 5436 case 0x07: 5437 case 0x08: 5438 case 0x09: 5439 case 0x0a: 5440 case 0x0b: 5441 case 0x0c: 5442 case 0x0d: 5443 case 0x0e: 5444 case 0x0f: 5445 { 5446 /** 0111 1111 0000 rsrc jmp %0 */ 5447 #line 791 "rx-decode.opc" 5448 int rsrc AU = op[1] & 0x0f; 5449 if (trace) 5450 { 5451 printf ("\033[33m%s\033[0m %02x %02x\n", 5452 "/** 0111 1111 0000 rsrc jmp %0 */", 5453 op[0], op[1]); 5454 printf (" rsrc = 0x%x\n", rsrc); 5455 } 5456 SYNTAX("jmp %0"); 5457 #line 791 "rx-decode.opc" 5458 ID(branch); DR(rsrc); 5459 5460 } 5461 break; 5462 case 0x10: 5463 case 0x11: 5464 case 0x12: 5465 case 0x13: 5466 case 0x14: 5467 case 0x15: 5468 case 0x16: 5469 case 0x17: 5470 case 0x18: 5471 case 0x19: 5472 case 0x1a: 5473 case 0x1b: 5474 case 0x1c: 5475 case 0x1d: 5476 case 0x1e: 5477 case 0x1f: 5478 { 5479 /** 0111 1111 0001 rsrc jsr %0 */ 5480 #line 794 "rx-decode.opc" 5481 int rsrc AU = op[1] & 0x0f; 5482 if (trace) 5483 { 5484 printf ("\033[33m%s\033[0m %02x %02x\n", 5485 "/** 0111 1111 0001 rsrc jsr %0 */", 5486 op[0], op[1]); 5487 printf (" rsrc = 0x%x\n", rsrc); 5488 } 5489 SYNTAX("jsr %0"); 5490 #line 794 "rx-decode.opc" 5491 ID(jsr); DR(rsrc); 5492 5493 } 5494 break; 5495 case 0x40: 5496 case 0x41: 5497 case 0x42: 5498 case 0x43: 5499 case 0x44: 5500 case 0x45: 5501 case 0x46: 5502 case 0x47: 5503 case 0x48: 5504 case 0x49: 5505 case 0x4a: 5506 case 0x4b: 5507 case 0x4c: 5508 case 0x4d: 5509 case 0x4e: 5510 case 0x4f: 5511 { 5512 /** 0111 1111 0100 rsrc bra.l %0 */ 5513 #line 787 "rx-decode.opc" 5514 int rsrc AU = op[1] & 0x0f; 5515 if (trace) 5516 { 5517 printf ("\033[33m%s\033[0m %02x %02x\n", 5518 "/** 0111 1111 0100 rsrc bra.l %0 */", 5519 op[0], op[1]); 5520 printf (" rsrc = 0x%x\n", rsrc); 5521 } 5522 SYNTAX("bra.l %0"); 5523 #line 787 "rx-decode.opc" 5524 ID(branchrel); DR(rsrc); 5525 5526 5527 } 5528 break; 5529 case 0x50: 5530 case 0x51: 5531 case 0x52: 5532 case 0x53: 5533 case 0x54: 5534 case 0x55: 5535 case 0x56: 5536 case 0x57: 5537 case 0x58: 5538 case 0x59: 5539 case 0x5a: 5540 case 0x5b: 5541 case 0x5c: 5542 case 0x5d: 5543 case 0x5e: 5544 case 0x5f: 5545 { 5546 /** 0111 1111 0101 rsrc bsr.l %0 */ 5547 #line 803 "rx-decode.opc" 5548 int rsrc AU = op[1] & 0x0f; 5549 if (trace) 5550 { 5551 printf ("\033[33m%s\033[0m %02x %02x\n", 5552 "/** 0111 1111 0101 rsrc bsr.l %0 */", 5553 op[0], op[1]); 5554 printf (" rsrc = 0x%x\n", rsrc); 5555 } 5556 SYNTAX("bsr.l %0"); 5557 #line 803 "rx-decode.opc" 5558 ID(jsrrel); DR(rsrc); 5559 5560 } 5561 break; 5562 case 0x80: 5563 case 0x81: 5564 case 0x82: 5565 { 5566 /** 0111 1111 1000 00sz suntil%s */ 5567 #line 827 "rx-decode.opc" 5568 int sz AU = op[1] & 0x03; 5569 if (trace) 5570 { 5571 printf ("\033[33m%s\033[0m %02x %02x\n", 5572 "/** 0111 1111 1000 00sz suntil%s */", 5573 op[0], op[1]); 5574 printf (" sz = 0x%x\n", sz); 5575 } 5576 SYNTAX("suntil%s"); 5577 #line 827 "rx-decode.opc" 5578 ID(suntil); BWL(sz); F___ZC; 5579 5580 } 5581 break; 5582 case 0x83: 5583 { 5584 /** 0111 1111 1000 0011 scmpu */ 5585 if (trace) 5586 { 5587 printf ("\033[33m%s\033[0m %02x %02x\n", 5588 "/** 0111 1111 1000 0011 scmpu */", 5589 op[0], op[1]); 5590 } 5591 SYNTAX("scmpu"); 5592 #line 818 "rx-decode.opc" 5593 ID(scmpu); F___ZC; 5594 5595 } 5596 break; 5597 case 0x84: 5598 case 0x85: 5599 case 0x86: 5600 { 5601 /** 0111 1111 1000 01sz swhile%s */ 5602 #line 830 "rx-decode.opc" 5603 int sz AU = op[1] & 0x03; 5604 if (trace) 5605 { 5606 printf ("\033[33m%s\033[0m %02x %02x\n", 5607 "/** 0111 1111 1000 01sz swhile%s */", 5608 op[0], op[1]); 5609 printf (" sz = 0x%x\n", sz); 5610 } 5611 SYNTAX("swhile%s"); 5612 #line 830 "rx-decode.opc" 5613 ID(swhile); BWL(sz); F___ZC; 5614 5615 } 5616 break; 5617 case 0x87: 5618 { 5619 /** 0111 1111 1000 0111 smovu */ 5620 if (trace) 5621 { 5622 printf ("\033[33m%s\033[0m %02x %02x\n", 5623 "/** 0111 1111 1000 0111 smovu */", 5624 op[0], op[1]); 5625 } 5626 SYNTAX("smovu"); 5627 #line 821 "rx-decode.opc" 5628 ID(smovu); 5629 5630 } 5631 break; 5632 case 0x88: 5633 case 0x89: 5634 case 0x8a: 5635 { 5636 /** 0111 1111 1000 10sz sstr%s */ 5637 #line 836 "rx-decode.opc" 5638 int sz AU = op[1] & 0x03; 5639 if (trace) 5640 { 5641 printf ("\033[33m%s\033[0m %02x %02x\n", 5642 "/** 0111 1111 1000 10sz sstr%s */", 5643 op[0], op[1]); 5644 printf (" sz = 0x%x\n", sz); 5645 } 5646 SYNTAX("sstr%s"); 5647 #line 836 "rx-decode.opc" 5648 ID(sstr); BWL(sz); 5649 5650 /*----------------------------------------------------------------------*/ 5651 /* RMPA */ 5652 5653 } 5654 break; 5655 case 0x8b: 5656 { 5657 /** 0111 1111 1000 1011 smovb */ 5658 if (trace) 5659 { 5660 printf ("\033[33m%s\033[0m %02x %02x\n", 5661 "/** 0111 1111 1000 1011 smovb */", 5662 op[0], op[1]); 5663 } 5664 SYNTAX("smovb"); 5665 #line 824 "rx-decode.opc" 5666 ID(smovb); 5667 5668 } 5669 break; 5670 case 0x8c: 5671 case 0x8d: 5672 case 0x8e: 5673 { 5674 /** 0111 1111 1000 11sz rmpa%s */ 5675 #line 842 "rx-decode.opc" 5676 int sz AU = op[1] & 0x03; 5677 if (trace) 5678 { 5679 printf ("\033[33m%s\033[0m %02x %02x\n", 5680 "/** 0111 1111 1000 11sz rmpa%s */", 5681 op[0], op[1]); 5682 printf (" sz = 0x%x\n", sz); 5683 } 5684 SYNTAX("rmpa%s"); 5685 #line 842 "rx-decode.opc" 5686 ID(rmpa); BWL(sz); F_OS__; 5687 5688 /*----------------------------------------------------------------------*/ 5689 /* HI/LO stuff */ 5690 5691 } 5692 break; 5693 case 0x8f: 5694 { 5695 /** 0111 1111 1000 1111 smovf */ 5696 if (trace) 5697 { 5698 printf ("\033[33m%s\033[0m %02x %02x\n", 5699 "/** 0111 1111 1000 1111 smovf */", 5700 op[0], op[1]); 5701 } 5702 SYNTAX("smovf"); 5703 #line 833 "rx-decode.opc" 5704 ID(smovf); 5705 5706 } 5707 break; 5708 case 0x93: 5709 { 5710 /** 0111 1111 1001 0011 satr */ 5711 if (trace) 5712 { 5713 printf ("\033[33m%s\033[0m %02x %02x\n", 5714 "/** 0111 1111 1001 0011 satr */", 5715 op[0], op[1]); 5716 } 5717 SYNTAX("satr"); 5718 #line 884 "rx-decode.opc" 5719 ID(satr); 5720 5721 /*----------------------------------------------------------------------*/ 5722 /* FLOAT */ 5723 5724 } 5725 break; 5726 case 0x94: 5727 { 5728 /** 0111 1111 1001 0100 rtfi */ 5729 if (trace) 5730 { 5731 printf ("\033[33m%s\033[0m %02x %02x\n", 5732 "/** 0111 1111 1001 0100 rtfi */", 5733 op[0], op[1]); 5734 } 5735 SYNTAX("rtfi"); 5736 #line 1019 "rx-decode.opc" 5737 ID(rtfi); 5738 5739 } 5740 break; 5741 case 0x95: 5742 { 5743 /** 0111 1111 1001 0101 rte */ 5744 if (trace) 5745 { 5746 printf ("\033[33m%s\033[0m %02x %02x\n", 5747 "/** 0111 1111 1001 0101 rte */", 5748 op[0], op[1]); 5749 } 5750 SYNTAX("rte"); 5751 #line 1022 "rx-decode.opc" 5752 ID(rte); 5753 5754 } 5755 break; 5756 case 0x96: 5757 { 5758 /** 0111 1111 1001 0110 wait */ 5759 if (trace) 5760 { 5761 printf ("\033[33m%s\033[0m %02x %02x\n", 5762 "/** 0111 1111 1001 0110 wait */", 5763 op[0], op[1]); 5764 } 5765 SYNTAX("wait"); 5766 #line 1034 "rx-decode.opc" 5767 ID(wait); 5768 5769 /*----------------------------------------------------------------------*/ 5770 /* SCcnd */ 5771 5772 } 5773 break; 5774 case 0xa0: 5775 case 0xa1: 5776 case 0xa2: 5777 case 0xa3: 5778 case 0xa4: 5779 case 0xa5: 5780 case 0xa6: 5781 case 0xa7: 5782 case 0xa8: 5783 case 0xa9: 5784 case 0xaa: 5785 case 0xab: 5786 case 0xac: 5787 case 0xad: 5788 case 0xae: 5789 case 0xaf: 5790 { 5791 /** 0111 1111 1010 rdst setpsw %0 */ 5792 #line 995 "rx-decode.opc" 5793 int rdst AU = op[1] & 0x0f; 5794 if (trace) 5795 { 5796 printf ("\033[33m%s\033[0m %02x %02x\n", 5797 "/** 0111 1111 1010 rdst setpsw %0 */", 5798 op[0], op[1]); 5799 printf (" rdst = 0x%x\n", rdst); 5800 } 5801 SYNTAX("setpsw %0"); 5802 #line 995 "rx-decode.opc" 5803 ID(setpsw); DF(rdst); 5804 5805 } 5806 break; 5807 case 0xb0: 5808 case 0xb1: 5809 case 0xb2: 5810 case 0xb3: 5811 case 0xb4: 5812 case 0xb5: 5813 case 0xb6: 5814 case 0xb7: 5815 case 0xb8: 5816 case 0xb9: 5817 case 0xba: 5818 case 0xbb: 5819 case 0xbc: 5820 case 0xbd: 5821 case 0xbe: 5822 case 0xbf: 5823 { 5824 /** 0111 1111 1011 rdst clrpsw %0 */ 5825 #line 992 "rx-decode.opc" 5826 int rdst AU = op[1] & 0x0f; 5827 if (trace) 5828 { 5829 printf ("\033[33m%s\033[0m %02x %02x\n", 5830 "/** 0111 1111 1011 rdst clrpsw %0 */", 5831 op[0], op[1]); 5832 printf (" rdst = 0x%x\n", rdst); 5833 } 5834 SYNTAX("clrpsw %0"); 5835 #line 992 "rx-decode.opc" 5836 ID(clrpsw); DF(rdst); 5837 5838 } 5839 break; 5840 default: UNSUPPORTED(); break; 5841 } 5842 break; 5843 case 0x80: 5844 GETBYTE (); 5845 switch (op[1] & 0x00) 5846 { 5847 case 0x00: 5848 op_semantics_39: 5849 { 5850 /** 10sz 0dsp a dst b src mov%s %1, %0 */ 5851 #line 332 "rx-decode.opc" 5852 int sz AU = (op[0] >> 4) & 0x03; 5853 #line 332 "rx-decode.opc" 5854 int dsp AU = op[0] & 0x07; 5855 #line 332 "rx-decode.opc" 5856 int a AU = (op[1] >> 7) & 0x01; 5857 #line 332 "rx-decode.opc" 5858 int dst AU = (op[1] >> 4) & 0x07; 5859 #line 332 "rx-decode.opc" 5860 int b AU = (op[1] >> 3) & 0x01; 5861 #line 332 "rx-decode.opc" 5862 int src AU = op[1] & 0x07; 5863 if (trace) 5864 { 5865 printf ("\033[33m%s\033[0m %02x %02x\n", 5866 "/** 10sz 0dsp a dst b src mov%s %1, %0 */", 5867 op[0], op[1]); 5868 printf (" sz = 0x%x,", sz); 5869 printf (" dsp = 0x%x,", dsp); 5870 printf (" a = 0x%x,", a); 5871 printf (" dst = 0x%x,", dst); 5872 printf (" b = 0x%x,", b); 5873 printf (" src = 0x%x\n", src); 5874 } 5875 SYNTAX("mov%s %1, %0"); 5876 #line 332 "rx-decode.opc" 5877 ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F_____; 5878 5879 } 5880 break; 5881 } 5882 break; 5883 case 0x81: 5884 GETBYTE (); 5885 switch (op[1] & 0x00) 5886 { 5887 case 0x00: 5888 goto op_semantics_39; 5889 break; 5890 } 5891 break; 5892 case 0x82: 5893 GETBYTE (); 5894 switch (op[1] & 0x00) 5895 { 5896 case 0x00: 5897 goto op_semantics_39; 5898 break; 5899 } 5900 break; 5901 case 0x83: 5902 GETBYTE (); 5903 switch (op[1] & 0x00) 5904 { 5905 case 0x00: 5906 goto op_semantics_39; 5907 break; 5908 } 5909 break; 5910 case 0x84: 5911 GETBYTE (); 5912 switch (op[1] & 0x00) 5913 { 5914 case 0x00: 5915 goto op_semantics_39; 5916 break; 5917 } 5918 break; 5919 case 0x85: 5920 GETBYTE (); 5921 switch (op[1] & 0x00) 5922 { 5923 case 0x00: 5924 goto op_semantics_39; 5925 break; 5926 } 5927 break; 5928 case 0x86: 5929 GETBYTE (); 5930 switch (op[1] & 0x00) 5931 { 5932 case 0x00: 5933 goto op_semantics_39; 5934 break; 5935 } 5936 break; 5937 case 0x87: 5938 GETBYTE (); 5939 switch (op[1] & 0x00) 5940 { 5941 case 0x00: 5942 goto op_semantics_39; 5943 break; 5944 } 5945 break; 5946 case 0x88: 5947 GETBYTE (); 5948 switch (op[1] & 0x00) 5949 { 5950 case 0x00: 5951 op_semantics_40: 5952 { 5953 /** 10sz 1dsp a src b dst mov%s %1, %0 */ 5954 #line 329 "rx-decode.opc" 5955 int sz AU = (op[0] >> 4) & 0x03; 5956 #line 329 "rx-decode.opc" 5957 int dsp AU = op[0] & 0x07; 5958 #line 329 "rx-decode.opc" 5959 int a AU = (op[1] >> 7) & 0x01; 5960 #line 329 "rx-decode.opc" 5961 int src AU = (op[1] >> 4) & 0x07; 5962 #line 329 "rx-decode.opc" 5963 int b AU = (op[1] >> 3) & 0x01; 5964 #line 329 "rx-decode.opc" 5965 int dst AU = op[1] & 0x07; 5966 if (trace) 5967 { 5968 printf ("\033[33m%s\033[0m %02x %02x\n", 5969 "/** 10sz 1dsp a src b dst mov%s %1, %0 */", 5970 op[0], op[1]); 5971 printf (" sz = 0x%x,", sz); 5972 printf (" dsp = 0x%x,", dsp); 5973 printf (" a = 0x%x,", a); 5974 printf (" src = 0x%x,", src); 5975 printf (" b = 0x%x,", b); 5976 printf (" dst = 0x%x\n", dst); 5977 } 5978 SYNTAX("mov%s %1, %0"); 5979 #line 329 "rx-decode.opc" 5980 ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F_____; 5981 5982 } 5983 break; 5984 } 5985 break; 5986 case 0x89: 5987 GETBYTE (); 5988 switch (op[1] & 0x00) 5989 { 5990 case 0x00: 5991 goto op_semantics_40; 5992 break; 5993 } 5994 break; 5995 case 0x8a: 5996 GETBYTE (); 5997 switch (op[1] & 0x00) 5998 { 5999 case 0x00: 6000 goto op_semantics_40; 6001 break; 6002 } 6003 break; 6004 case 0x8b: 6005 GETBYTE (); 6006 switch (op[1] & 0x00) 6007 { 6008 case 0x00: 6009 goto op_semantics_40; 6010 break; 6011 } 6012 break; 6013 case 0x8c: 6014 GETBYTE (); 6015 switch (op[1] & 0x00) 6016 { 6017 case 0x00: 6018 goto op_semantics_40; 6019 break; 6020 } 6021 break; 6022 case 0x8d: 6023 GETBYTE (); 6024 switch (op[1] & 0x00) 6025 { 6026 case 0x00: 6027 goto op_semantics_40; 6028 break; 6029 } 6030 break; 6031 case 0x8e: 6032 GETBYTE (); 6033 switch (op[1] & 0x00) 6034 { 6035 case 0x00: 6036 goto op_semantics_40; 6037 break; 6038 } 6039 break; 6040 case 0x8f: 6041 GETBYTE (); 6042 switch (op[1] & 0x00) 6043 { 6044 case 0x00: 6045 goto op_semantics_40; 6046 break; 6047 } 6048 break; 6049 case 0x90: 6050 GETBYTE (); 6051 switch (op[1] & 0x00) 6052 { 6053 case 0x00: 6054 goto op_semantics_39; 6055 break; 6056 } 6057 break; 6058 case 0x91: 6059 GETBYTE (); 6060 switch (op[1] & 0x00) 6061 { 6062 case 0x00: 6063 goto op_semantics_39; 6064 break; 6065 } 6066 break; 6067 case 0x92: 6068 GETBYTE (); 6069 switch (op[1] & 0x00) 6070 { 6071 case 0x00: 6072 goto op_semantics_39; 6073 break; 6074 } 6075 break; 6076 case 0x93: 6077 GETBYTE (); 6078 switch (op[1] & 0x00) 6079 { 6080 case 0x00: 6081 goto op_semantics_39; 6082 break; 6083 } 6084 break; 6085 case 0x94: 6086 GETBYTE (); 6087 switch (op[1] & 0x00) 6088 { 6089 case 0x00: 6090 goto op_semantics_39; 6091 break; 6092 } 6093 break; 6094 case 0x95: 6095 GETBYTE (); 6096 switch (op[1] & 0x00) 6097 { 6098 case 0x00: 6099 goto op_semantics_39; 6100 break; 6101 } 6102 break; 6103 case 0x96: 6104 GETBYTE (); 6105 switch (op[1] & 0x00) 6106 { 6107 case 0x00: 6108 goto op_semantics_39; 6109 break; 6110 } 6111 break; 6112 case 0x97: 6113 GETBYTE (); 6114 switch (op[1] & 0x00) 6115 { 6116 case 0x00: 6117 goto op_semantics_39; 6118 break; 6119 } 6120 break; 6121 case 0x98: 6122 GETBYTE (); 6123 switch (op[1] & 0x00) 6124 { 6125 case 0x00: 6126 goto op_semantics_40; 6127 break; 6128 } 6129 break; 6130 case 0x99: 6131 GETBYTE (); 6132 switch (op[1] & 0x00) 6133 { 6134 case 0x00: 6135 goto op_semantics_40; 6136 break; 6137 } 6138 break; 6139 case 0x9a: 6140 GETBYTE (); 6141 switch (op[1] & 0x00) 6142 { 6143 case 0x00: 6144 goto op_semantics_40; 6145 break; 6146 } 6147 break; 6148 case 0x9b: 6149 GETBYTE (); 6150 switch (op[1] & 0x00) 6151 { 6152 case 0x00: 6153 goto op_semantics_40; 6154 break; 6155 } 6156 break; 6157 case 0x9c: 6158 GETBYTE (); 6159 switch (op[1] & 0x00) 6160 { 6161 case 0x00: 6162 goto op_semantics_40; 6163 break; 6164 } 6165 break; 6166 case 0x9d: 6167 GETBYTE (); 6168 switch (op[1] & 0x00) 6169 { 6170 case 0x00: 6171 goto op_semantics_40; 6172 break; 6173 } 6174 break; 6175 case 0x9e: 6176 GETBYTE (); 6177 switch (op[1] & 0x00) 6178 { 6179 case 0x00: 6180 goto op_semantics_40; 6181 break; 6182 } 6183 break; 6184 case 0x9f: 6185 GETBYTE (); 6186 switch (op[1] & 0x00) 6187 { 6188 case 0x00: 6189 goto op_semantics_40; 6190 break; 6191 } 6192 break; 6193 case 0xa0: 6194 GETBYTE (); 6195 switch (op[1] & 0x00) 6196 { 6197 case 0x00: 6198 goto op_semantics_39; 6199 break; 6200 } 6201 break; 6202 case 0xa1: 6203 GETBYTE (); 6204 switch (op[1] & 0x00) 6205 { 6206 case 0x00: 6207 goto op_semantics_39; 6208 break; 6209 } 6210 break; 6211 case 0xa2: 6212 GETBYTE (); 6213 switch (op[1] & 0x00) 6214 { 6215 case 0x00: 6216 goto op_semantics_39; 6217 break; 6218 } 6219 break; 6220 case 0xa3: 6221 GETBYTE (); 6222 switch (op[1] & 0x00) 6223 { 6224 case 0x00: 6225 goto op_semantics_39; 6226 break; 6227 } 6228 break; 6229 case 0xa4: 6230 GETBYTE (); 6231 switch (op[1] & 0x00) 6232 { 6233 case 0x00: 6234 goto op_semantics_39; 6235 break; 6236 } 6237 break; 6238 case 0xa5: 6239 GETBYTE (); 6240 switch (op[1] & 0x00) 6241 { 6242 case 0x00: 6243 goto op_semantics_39; 6244 break; 6245 } 6246 break; 6247 case 0xa6: 6248 GETBYTE (); 6249 switch (op[1] & 0x00) 6250 { 6251 case 0x00: 6252 goto op_semantics_39; 6253 break; 6254 } 6255 break; 6256 case 0xa7: 6257 GETBYTE (); 6258 switch (op[1] & 0x00) 6259 { 6260 case 0x00: 6261 goto op_semantics_39; 6262 break; 6263 } 6264 break; 6265 case 0xa8: 6266 GETBYTE (); 6267 switch (op[1] & 0x00) 6268 { 6269 case 0x00: 6270 goto op_semantics_40; 6271 break; 6272 } 6273 break; 6274 case 0xa9: 6275 GETBYTE (); 6276 switch (op[1] & 0x00) 6277 { 6278 case 0x00: 6279 goto op_semantics_40; 6280 break; 6281 } 6282 break; 6283 case 0xaa: 6284 GETBYTE (); 6285 switch (op[1] & 0x00) 6286 { 6287 case 0x00: 6288 goto op_semantics_40; 6289 break; 6290 } 6291 break; 6292 case 0xab: 6293 GETBYTE (); 6294 switch (op[1] & 0x00) 6295 { 6296 case 0x00: 6297 goto op_semantics_40; 6298 break; 6299 } 6300 break; 6301 case 0xac: 6302 GETBYTE (); 6303 switch (op[1] & 0x00) 6304 { 6305 case 0x00: 6306 goto op_semantics_40; 6307 break; 6308 } 6309 break; 6310 case 0xad: 6311 GETBYTE (); 6312 switch (op[1] & 0x00) 6313 { 6314 case 0x00: 6315 goto op_semantics_40; 6316 break; 6317 } 6318 break; 6319 case 0xae: 6320 GETBYTE (); 6321 switch (op[1] & 0x00) 6322 { 6323 case 0x00: 6324 goto op_semantics_40; 6325 break; 6326 } 6327 break; 6328 case 0xaf: 6329 GETBYTE (); 6330 switch (op[1] & 0x00) 6331 { 6332 case 0x00: 6333 goto op_semantics_40; 6334 break; 6335 } 6336 break; 6337 case 0xb0: 6338 GETBYTE (); 6339 switch (op[1] & 0x00) 6340 { 6341 case 0x00: 6342 op_semantics_41: 6343 { 6344 /** 1011 w dsp a src b dst movu%s %1, %0 */ 6345 #line 352 "rx-decode.opc" 6346 int w AU = (op[0] >> 3) & 0x01; 6347 #line 352 "rx-decode.opc" 6348 int dsp AU = op[0] & 0x07; 6349 #line 352 "rx-decode.opc" 6350 int a AU = (op[1] >> 7) & 0x01; 6351 #line 352 "rx-decode.opc" 6352 int src AU = (op[1] >> 4) & 0x07; 6353 #line 352 "rx-decode.opc" 6354 int b AU = (op[1] >> 3) & 0x01; 6355 #line 352 "rx-decode.opc" 6356 int dst AU = op[1] & 0x07; 6357 if (trace) 6358 { 6359 printf ("\033[33m%s\033[0m %02x %02x\n", 6360 "/** 1011 w dsp a src b dst movu%s %1, %0 */", 6361 op[0], op[1]); 6362 printf (" w = 0x%x,", w); 6363 printf (" dsp = 0x%x,", dsp); 6364 printf (" a = 0x%x,", a); 6365 printf (" src = 0x%x,", src); 6366 printf (" b = 0x%x,", b); 6367 printf (" dst = 0x%x\n", dst); 6368 } 6369 SYNTAX("movu%s %1, %0"); 6370 #line 352 "rx-decode.opc" 6371 ID(mov); uBW(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F_____; 6372 6373 } 6374 break; 6375 } 6376 break; 6377 case 0xb1: 6378 GETBYTE (); 6379 switch (op[1] & 0x00) 6380 { 6381 case 0x00: 6382 goto op_semantics_41; 6383 break; 6384 } 6385 break; 6386 case 0xb2: 6387 GETBYTE (); 6388 switch (op[1] & 0x00) 6389 { 6390 case 0x00: 6391 goto op_semantics_41; 6392 break; 6393 } 6394 break; 6395 case 0xb3: 6396 GETBYTE (); 6397 switch (op[1] & 0x00) 6398 { 6399 case 0x00: 6400 goto op_semantics_41; 6401 break; 6402 } 6403 break; 6404 case 0xb4: 6405 GETBYTE (); 6406 switch (op[1] & 0x00) 6407 { 6408 case 0x00: 6409 goto op_semantics_41; 6410 break; 6411 } 6412 break; 6413 case 0xb5: 6414 GETBYTE (); 6415 switch (op[1] & 0x00) 6416 { 6417 case 0x00: 6418 goto op_semantics_41; 6419 break; 6420 } 6421 break; 6422 case 0xb6: 6423 GETBYTE (); 6424 switch (op[1] & 0x00) 6425 { 6426 case 0x00: 6427 goto op_semantics_41; 6428 break; 6429 } 6430 break; 6431 case 0xb7: 6432 GETBYTE (); 6433 switch (op[1] & 0x00) 6434 { 6435 case 0x00: 6436 goto op_semantics_41; 6437 break; 6438 } 6439 break; 6440 case 0xb8: 6441 GETBYTE (); 6442 switch (op[1] & 0x00) 6443 { 6444 case 0x00: 6445 goto op_semantics_41; 6446 break; 6447 } 6448 break; 6449 case 0xb9: 6450 GETBYTE (); 6451 switch (op[1] & 0x00) 6452 { 6453 case 0x00: 6454 goto op_semantics_41; 6455 break; 6456 } 6457 break; 6458 case 0xba: 6459 GETBYTE (); 6460 switch (op[1] & 0x00) 6461 { 6462 case 0x00: 6463 goto op_semantics_41; 6464 break; 6465 } 6466 break; 6467 case 0xbb: 6468 GETBYTE (); 6469 switch (op[1] & 0x00) 6470 { 6471 case 0x00: 6472 goto op_semantics_41; 6473 break; 6474 } 6475 break; 6476 case 0xbc: 6477 GETBYTE (); 6478 switch (op[1] & 0x00) 6479 { 6480 case 0x00: 6481 goto op_semantics_41; 6482 break; 6483 } 6484 break; 6485 case 0xbd: 6486 GETBYTE (); 6487 switch (op[1] & 0x00) 6488 { 6489 case 0x00: 6490 goto op_semantics_41; 6491 break; 6492 } 6493 break; 6494 case 0xbe: 6495 GETBYTE (); 6496 switch (op[1] & 0x00) 6497 { 6498 case 0x00: 6499 goto op_semantics_41; 6500 break; 6501 } 6502 break; 6503 case 0xbf: 6504 GETBYTE (); 6505 switch (op[1] & 0x00) 6506 { 6507 case 0x00: 6508 goto op_semantics_41; 6509 break; 6510 } 6511 break; 6512 case 0xc0: 6513 GETBYTE (); 6514 switch (op[1] & 0x00) 6515 { 6516 case 0x00: 6517 op_semantics_42: 6518 { 6519 /** 11sz sd ss rsrc rdst mov%s %1, %0 */ 6520 #line 310 "rx-decode.opc" 6521 int sz AU = (op[0] >> 4) & 0x03; 6522 #line 310 "rx-decode.opc" 6523 int sd AU = (op[0] >> 2) & 0x03; 6524 #line 310 "rx-decode.opc" 6525 int ss AU = op[0] & 0x03; 6526 #line 310 "rx-decode.opc" 6527 int rsrc AU = (op[1] >> 4) & 0x0f; 6528 #line 310 "rx-decode.opc" 6529 int rdst AU = op[1] & 0x0f; 6530 if (trace) 6531 { 6532 printf ("\033[33m%s\033[0m %02x %02x\n", 6533 "/** 11sz sd ss rsrc rdst mov%s %1, %0 */", 6534 op[0], op[1]); 6535 printf (" sz = 0x%x,", sz); 6536 printf (" sd = 0x%x,", sd); 6537 printf (" ss = 0x%x,", ss); 6538 printf (" rsrc = 0x%x,", rsrc); 6539 printf (" rdst = 0x%x\n", rdst); 6540 } 6541 SYNTAX("mov%s %1, %0"); 6542 #line 310 "rx-decode.opc" 6543 if (sd == 3 && ss == 3 && sz == 2 && rsrc == 0 && rdst == 0) 6544 { 6545 ID(nop2); 6546 SYNTAX ("nop\t; mov.l\tr0, r0"); 6547 } 6548 else 6549 { 6550 ID(mov); sBWL(sz); F_____; 6551 if ((ss == 3) && (sd != 3)) 6552 { 6553 SD(ss, rdst, sz); DD(sd, rsrc, sz); 6554 } 6555 else 6556 { 6557 SD(ss, rsrc, sz); DD(sd, rdst, sz); 6558 } 6559 } 6560 6561 } 6562 break; 6563 } 6564 break; 6565 case 0xc1: 6566 GETBYTE (); 6567 switch (op[1] & 0x00) 6568 { 6569 case 0x00: 6570 goto op_semantics_42; 6571 break; 6572 } 6573 break; 6574 case 0xc2: 6575 GETBYTE (); 6576 switch (op[1] & 0x00) 6577 { 6578 case 0x00: 6579 goto op_semantics_42; 6580 break; 6581 } 6582 break; 6583 case 0xc3: 6584 GETBYTE (); 6585 switch (op[1] & 0x00) 6586 { 6587 case 0x00: 6588 goto op_semantics_42; 6589 break; 6590 } 6591 break; 6592 case 0xc4: 6593 GETBYTE (); 6594 switch (op[1] & 0x00) 6595 { 6596 case 0x00: 6597 goto op_semantics_42; 6598 break; 6599 } 6600 break; 6601 case 0xc5: 6602 GETBYTE (); 6603 switch (op[1] & 0x00) 6604 { 6605 case 0x00: 6606 goto op_semantics_42; 6607 break; 6608 } 6609 break; 6610 case 0xc6: 6611 GETBYTE (); 6612 switch (op[1] & 0x00) 6613 { 6614 case 0x00: 6615 goto op_semantics_42; 6616 break; 6617 } 6618 break; 6619 case 0xc7: 6620 GETBYTE (); 6621 switch (op[1] & 0x00) 6622 { 6623 case 0x00: 6624 goto op_semantics_42; 6625 break; 6626 } 6627 break; 6628 case 0xc8: 6629 GETBYTE (); 6630 switch (op[1] & 0x00) 6631 { 6632 case 0x00: 6633 goto op_semantics_42; 6634 break; 6635 } 6636 break; 6637 case 0xc9: 6638 GETBYTE (); 6639 switch (op[1] & 0x00) 6640 { 6641 case 0x00: 6642 goto op_semantics_42; 6643 break; 6644 } 6645 break; 6646 case 0xca: 6647 GETBYTE (); 6648 switch (op[1] & 0x00) 6649 { 6650 case 0x00: 6651 goto op_semantics_42; 6652 break; 6653 } 6654 break; 6655 case 0xcb: 6656 GETBYTE (); 6657 switch (op[1] & 0x00) 6658 { 6659 case 0x00: 6660 goto op_semantics_42; 6661 break; 6662 } 6663 break; 6664 case 0xcc: 6665 GETBYTE (); 6666 switch (op[1] & 0x00) 6667 { 6668 case 0x00: 6669 goto op_semantics_42; 6670 break; 6671 } 6672 break; 6673 case 0xcd: 6674 GETBYTE (); 6675 switch (op[1] & 0x00) 6676 { 6677 case 0x00: 6678 goto op_semantics_42; 6679 break; 6680 } 6681 break; 6682 case 0xce: 6683 GETBYTE (); 6684 switch (op[1] & 0x00) 6685 { 6686 case 0x00: 6687 goto op_semantics_42; 6688 break; 6689 } 6690 break; 6691 case 0xcf: 6692 GETBYTE (); 6693 switch (op[1] & 0x00) 6694 { 6695 case 0x00: 6696 goto op_semantics_42; 6697 break; 6698 } 6699 break; 6700 case 0xd0: 6701 GETBYTE (); 6702 switch (op[1] & 0x00) 6703 { 6704 case 0x00: 6705 goto op_semantics_42; 6706 break; 6707 } 6708 break; 6709 case 0xd1: 6710 GETBYTE (); 6711 switch (op[1] & 0x00) 6712 { 6713 case 0x00: 6714 goto op_semantics_42; 6715 break; 6716 } 6717 break; 6718 case 0xd2: 6719 GETBYTE (); 6720 switch (op[1] & 0x00) 6721 { 6722 case 0x00: 6723 goto op_semantics_42; 6724 break; 6725 } 6726 break; 6727 case 0xd3: 6728 GETBYTE (); 6729 switch (op[1] & 0x00) 6730 { 6731 case 0x00: 6732 goto op_semantics_42; 6733 break; 6734 } 6735 break; 6736 case 0xd4: 6737 GETBYTE (); 6738 switch (op[1] & 0x00) 6739 { 6740 case 0x00: 6741 goto op_semantics_42; 6742 break; 6743 } 6744 break; 6745 case 0xd5: 6746 GETBYTE (); 6747 switch (op[1] & 0x00) 6748 { 6749 case 0x00: 6750 goto op_semantics_42; 6751 break; 6752 } 6753 break; 6754 case 0xd6: 6755 GETBYTE (); 6756 switch (op[1] & 0x00) 6757 { 6758 case 0x00: 6759 goto op_semantics_42; 6760 break; 6761 } 6762 break; 6763 case 0xd7: 6764 GETBYTE (); 6765 switch (op[1] & 0x00) 6766 { 6767 case 0x00: 6768 goto op_semantics_42; 6769 break; 6770 } 6771 break; 6772 case 0xd8: 6773 GETBYTE (); 6774 switch (op[1] & 0x00) 6775 { 6776 case 0x00: 6777 goto op_semantics_42; 6778 break; 6779 } 6780 break; 6781 case 0xd9: 6782 GETBYTE (); 6783 switch (op[1] & 0x00) 6784 { 6785 case 0x00: 6786 goto op_semantics_42; 6787 break; 6788 } 6789 break; 6790 case 0xda: 6791 GETBYTE (); 6792 switch (op[1] & 0x00) 6793 { 6794 case 0x00: 6795 goto op_semantics_42; 6796 break; 6797 } 6798 break; 6799 case 0xdb: 6800 GETBYTE (); 6801 switch (op[1] & 0x00) 6802 { 6803 case 0x00: 6804 goto op_semantics_42; 6805 break; 6806 } 6807 break; 6808 case 0xdc: 6809 GETBYTE (); 6810 switch (op[1] & 0x00) 6811 { 6812 case 0x00: 6813 goto op_semantics_42; 6814 break; 6815 } 6816 break; 6817 case 0xdd: 6818 GETBYTE (); 6819 switch (op[1] & 0x00) 6820 { 6821 case 0x00: 6822 goto op_semantics_42; 6823 break; 6824 } 6825 break; 6826 case 0xde: 6827 GETBYTE (); 6828 switch (op[1] & 0x00) 6829 { 6830 case 0x00: 6831 goto op_semantics_42; 6832 break; 6833 } 6834 break; 6835 case 0xdf: 6836 GETBYTE (); 6837 switch (op[1] & 0x00) 6838 { 6839 case 0x00: 6840 goto op_semantics_42; 6841 break; 6842 } 6843 break; 6844 case 0xe0: 6845 GETBYTE (); 6846 switch (op[1] & 0x00) 6847 { 6848 case 0x00: 6849 goto op_semantics_42; 6850 break; 6851 } 6852 break; 6853 case 0xe1: 6854 GETBYTE (); 6855 switch (op[1] & 0x00) 6856 { 6857 case 0x00: 6858 goto op_semantics_42; 6859 break; 6860 } 6861 break; 6862 case 0xe2: 6863 GETBYTE (); 6864 switch (op[1] & 0x00) 6865 { 6866 case 0x00: 6867 goto op_semantics_42; 6868 break; 6869 } 6870 break; 6871 case 0xe3: 6872 GETBYTE (); 6873 switch (op[1] & 0x00) 6874 { 6875 case 0x00: 6876 goto op_semantics_42; 6877 break; 6878 } 6879 break; 6880 case 0xe4: 6881 GETBYTE (); 6882 switch (op[1] & 0x00) 6883 { 6884 case 0x00: 6885 goto op_semantics_42; 6886 break; 6887 } 6888 break; 6889 case 0xe5: 6890 GETBYTE (); 6891 switch (op[1] & 0x00) 6892 { 6893 case 0x00: 6894 goto op_semantics_42; 6895 break; 6896 } 6897 break; 6898 case 0xe6: 6899 GETBYTE (); 6900 switch (op[1] & 0x00) 6901 { 6902 case 0x00: 6903 goto op_semantics_42; 6904 break; 6905 } 6906 break; 6907 case 0xe7: 6908 GETBYTE (); 6909 switch (op[1] & 0x00) 6910 { 6911 case 0x00: 6912 goto op_semantics_42; 6913 break; 6914 } 6915 break; 6916 case 0xe8: 6917 GETBYTE (); 6918 switch (op[1] & 0x00) 6919 { 6920 case 0x00: 6921 goto op_semantics_42; 6922 break; 6923 } 6924 break; 6925 case 0xe9: 6926 GETBYTE (); 6927 switch (op[1] & 0x00) 6928 { 6929 case 0x00: 6930 goto op_semantics_42; 6931 break; 6932 } 6933 break; 6934 case 0xea: 6935 GETBYTE (); 6936 switch (op[1] & 0x00) 6937 { 6938 case 0x00: 6939 goto op_semantics_42; 6940 break; 6941 } 6942 break; 6943 case 0xeb: 6944 GETBYTE (); 6945 switch (op[1] & 0x00) 6946 { 6947 case 0x00: 6948 goto op_semantics_42; 6949 break; 6950 } 6951 break; 6952 case 0xec: 6953 GETBYTE (); 6954 switch (op[1] & 0x00) 6955 { 6956 case 0x00: 6957 goto op_semantics_42; 6958 break; 6959 } 6960 break; 6961 case 0xed: 6962 GETBYTE (); 6963 switch (op[1] & 0x00) 6964 { 6965 case 0x00: 6966 goto op_semantics_42; 6967 break; 6968 } 6969 break; 6970 case 0xee: 6971 GETBYTE (); 6972 switch (op[1] & 0x00) 6973 { 6974 case 0x00: 6975 goto op_semantics_42; 6976 break; 6977 } 6978 break; 6979 case 0xef: 6980 GETBYTE (); 6981 switch (op[1] & 0x00) 6982 { 6983 case 0x00: 6984 goto op_semantics_42; 6985 break; 6986 } 6987 break; 6988 case 0xf0: 6989 GETBYTE (); 6990 switch (op[1] & 0x08) 6991 { 6992 case 0x00: 6993 op_semantics_43: 6994 { 6995 /** 1111 00sd rdst 0bit bset #%1, %0%S0 */ 6996 #line 935 "rx-decode.opc" 6997 int sd AU = op[0] & 0x03; 6998 #line 935 "rx-decode.opc" 6999 int rdst AU = (op[1] >> 4) & 0x0f; 7000 #line 935 "rx-decode.opc" 7001 int bit AU = op[1] & 0x07; 7002 if (trace) 7003 { 7004 printf ("\033[33m%s\033[0m %02x %02x\n", 7005 "/** 1111 00sd rdst 0bit bset #%1, %0%S0 */", 7006 op[0], op[1]); 7007 printf (" sd = 0x%x,", sd); 7008 printf (" rdst = 0x%x,", rdst); 7009 printf (" bit = 0x%x\n", bit); 7010 } 7011 SYNTAX("bset #%1, %0%S0"); 7012 #line 935 "rx-decode.opc" 7013 ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____; 7014 7015 } 7016 break; 7017 case 0x08: 7018 op_semantics_44: 7019 { 7020 /** 1111 00sd rdst 1bit bclr #%1, %0%S0 */ 7021 #line 947 "rx-decode.opc" 7022 int sd AU = op[0] & 0x03; 7023 #line 947 "rx-decode.opc" 7024 int rdst AU = (op[1] >> 4) & 0x0f; 7025 #line 947 "rx-decode.opc" 7026 int bit AU = op[1] & 0x07; 7027 if (trace) 7028 { 7029 printf ("\033[33m%s\033[0m %02x %02x\n", 7030 "/** 1111 00sd rdst 1bit bclr #%1, %0%S0 */", 7031 op[0], op[1]); 7032 printf (" sd = 0x%x,", sd); 7033 printf (" rdst = 0x%x,", rdst); 7034 printf (" bit = 0x%x\n", bit); 7035 } 7036 SYNTAX("bclr #%1, %0%S0"); 7037 #line 947 "rx-decode.opc" 7038 ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____; 7039 7040 } 7041 break; 7042 } 7043 break; 7044 case 0xf1: 7045 GETBYTE (); 7046 switch (op[1] & 0x08) 7047 { 7048 case 0x00: 7049 goto op_semantics_43; 7050 break; 7051 case 0x08: 7052 goto op_semantics_44; 7053 break; 7054 } 7055 break; 7056 case 0xf2: 7057 GETBYTE (); 7058 switch (op[1] & 0x08) 7059 { 7060 case 0x00: 7061 goto op_semantics_43; 7062 break; 7063 case 0x08: 7064 goto op_semantics_44; 7065 break; 7066 } 7067 break; 7068 case 0xf3: 7069 GETBYTE (); 7070 switch (op[1] & 0x08) 7071 { 7072 case 0x00: 7073 goto op_semantics_43; 7074 break; 7075 case 0x08: 7076 goto op_semantics_44; 7077 break; 7078 } 7079 break; 7080 case 0xf4: 7081 GETBYTE (); 7082 switch (op[1] & 0x0c) 7083 { 7084 case 0x00: 7085 case 0x04: 7086 op_semantics_45: 7087 { 7088 /** 1111 01sd rdst 0bit btst #%2, %1%S1 */ 7089 #line 959 "rx-decode.opc" 7090 int sd AU = op[0] & 0x03; 7091 #line 959 "rx-decode.opc" 7092 int rdst AU = (op[1] >> 4) & 0x0f; 7093 #line 959 "rx-decode.opc" 7094 int bit AU = op[1] & 0x07; 7095 if (trace) 7096 { 7097 printf ("\033[33m%s\033[0m %02x %02x\n", 7098 "/** 1111 01sd rdst 0bit btst #%2, %1%S1 */", 7099 op[0], op[1]); 7100 printf (" sd = 0x%x,", sd); 7101 printf (" rdst = 0x%x,", rdst); 7102 printf (" bit = 0x%x\n", bit); 7103 } 7104 SYNTAX("btst #%2, %1%S1"); 7105 #line 959 "rx-decode.opc" 7106 ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F___ZC; 7107 7108 } 7109 break; 7110 case 0x08: 7111 op_semantics_46: 7112 { 7113 /** 1111 01ss rsrc 10sz push%s %1 */ 7114 #line 377 "rx-decode.opc" 7115 int ss AU = op[0] & 0x03; 7116 #line 377 "rx-decode.opc" 7117 int rsrc AU = (op[1] >> 4) & 0x0f; 7118 #line 377 "rx-decode.opc" 7119 int sz AU = op[1] & 0x03; 7120 if (trace) 7121 { 7122 printf ("\033[33m%s\033[0m %02x %02x\n", 7123 "/** 1111 01ss rsrc 10sz push%s %1 */", 7124 op[0], op[1]); 7125 printf (" ss = 0x%x,", ss); 7126 printf (" rsrc = 0x%x,", rsrc); 7127 printf (" sz = 0x%x\n", sz); 7128 } 7129 SYNTAX("push%s %1"); 7130 #line 377 "rx-decode.opc" 7131 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F_____; 7132 7133 /*----------------------------------------------------------------------*/ 7134 /* XCHG */ 7135 7136 } 7137 break; 7138 default: UNSUPPORTED(); break; 7139 } 7140 break; 7141 case 0xf5: 7142 GETBYTE (); 7143 switch (op[1] & 0x0c) 7144 { 7145 case 0x00: 7146 case 0x04: 7147 goto op_semantics_45; 7148 break; 7149 case 0x08: 7150 goto op_semantics_46; 7151 break; 7152 default: UNSUPPORTED(); break; 7153 } 7154 break; 7155 case 0xf6: 7156 GETBYTE (); 7157 switch (op[1] & 0x0c) 7158 { 7159 case 0x00: 7160 case 0x04: 7161 goto op_semantics_45; 7162 break; 7163 case 0x08: 7164 goto op_semantics_46; 7165 break; 7166 default: UNSUPPORTED(); break; 7167 } 7168 break; 7169 case 0xf7: 7170 GETBYTE (); 7171 switch (op[1] & 0x0c) 7172 { 7173 case 0x00: 7174 case 0x04: 7175 goto op_semantics_45; 7176 break; 7177 case 0x08: 7178 goto op_semantics_46; 7179 break; 7180 default: UNSUPPORTED(); break; 7181 } 7182 break; 7183 case 0xf8: 7184 GETBYTE (); 7185 switch (op[1] & 0x00) 7186 { 7187 case 0x00: 7188 op_semantics_47: 7189 { 7190 /** 1111 10sd rdst im sz mov%s #%1, %0 */ 7191 #line 288 "rx-decode.opc" 7192 int sd AU = op[0] & 0x03; 7193 #line 288 "rx-decode.opc" 7194 int rdst AU = (op[1] >> 4) & 0x0f; 7195 #line 288 "rx-decode.opc" 7196 int im AU = (op[1] >> 2) & 0x03; 7197 #line 288 "rx-decode.opc" 7198 int sz AU = op[1] & 0x03; 7199 if (trace) 7200 { 7201 printf ("\033[33m%s\033[0m %02x %02x\n", 7202 "/** 1111 10sd rdst im sz mov%s #%1, %0 */", 7203 op[0], op[1]); 7204 printf (" sd = 0x%x,", sd); 7205 printf (" rdst = 0x%x,", rdst); 7206 printf (" im = 0x%x,", im); 7207 printf (" sz = 0x%x\n", sz); 7208 } 7209 SYNTAX("mov%s #%1, %0"); 7210 #line 288 "rx-decode.opc" 7211 ID(mov); DD(sd, rdst, sz); 7212 if ((im == 1 && sz == 0) 7213 || (im == 2 && sz == 1) 7214 || (im == 0 && sz == 2)) 7215 { 7216 BWL (sz); 7217 SC(IMM(im)); 7218 } 7219 else 7220 { 7221 sBWL (sz); 7222 SC(IMMex(im)); 7223 } 7224 F_____; 7225 7226 } 7227 break; 7228 } 7229 break; 7230 case 0xf9: 7231 GETBYTE (); 7232 switch (op[1] & 0x00) 7233 { 7234 case 0x00: 7235 goto op_semantics_47; 7236 break; 7237 } 7238 break; 7239 case 0xfa: 7240 GETBYTE (); 7241 switch (op[1] & 0x00) 7242 { 7243 case 0x00: 7244 goto op_semantics_47; 7245 break; 7246 } 7247 break; 7248 case 0xfb: 7249 GETBYTE (); 7250 switch (op[1] & 0x00) 7251 { 7252 case 0x00: 7253 goto op_semantics_47; 7254 break; 7255 } 7256 break; 7257 case 0xfc: 7258 GETBYTE (); 7259 switch (op[1] & 0xff) 7260 { 7261 case 0x03: 7262 GETBYTE (); 7263 switch (op[2] & 0x00) 7264 { 7265 case 0x00: 7266 { 7267 /** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */ 7268 #line 551 "rx-decode.opc" 7269 int rsrc AU = (op[2] >> 4) & 0x0f; 7270 #line 551 "rx-decode.opc" 7271 int rdst AU = op[2] & 0x0f; 7272 if (trace) 7273 { 7274 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7275 "/** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */", 7276 op[0], op[1], op[2]); 7277 printf (" rsrc = 0x%x,", rsrc); 7278 printf (" rdst = 0x%x\n", rdst); 7279 } 7280 SYNTAX("sbb %1, %0"); 7281 #line 551 "rx-decode.opc" 7282 ID(sbb); SR (rsrc); DR(rdst); F_OSZC; 7283 7284 /* FIXME: only supports .L */ 7285 } 7286 break; 7287 } 7288 break; 7289 case 0x07: 7290 GETBYTE (); 7291 switch (op[2] & 0x00) 7292 { 7293 case 0x00: 7294 { 7295 /** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */ 7296 #line 482 "rx-decode.opc" 7297 int rsrc AU = (op[2] >> 4) & 0x0f; 7298 #line 482 "rx-decode.opc" 7299 int rdst AU = op[2] & 0x0f; 7300 if (trace) 7301 { 7302 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7303 "/** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */", 7304 op[0], op[1], op[2]); 7305 printf (" rsrc = 0x%x,", rsrc); 7306 printf (" rdst = 0x%x\n", rdst); 7307 } 7308 SYNTAX("neg %2, %0"); 7309 #line 482 "rx-decode.opc" 7310 ID(sub); DR(rdst); SC(0); S2R(rsrc); F_OSZC; 7311 7312 /*----------------------------------------------------------------------*/ 7313 /* ADC */ 7314 7315 } 7316 break; 7317 } 7318 break; 7319 case 0x0b: 7320 GETBYTE (); 7321 switch (op[2] & 0x00) 7322 { 7323 case 0x00: 7324 { 7325 /** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */ 7326 #line 491 "rx-decode.opc" 7327 int rsrc AU = (op[2] >> 4) & 0x0f; 7328 #line 491 "rx-decode.opc" 7329 int rdst AU = op[2] & 0x0f; 7330 if (trace) 7331 { 7332 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7333 "/** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */", 7334 op[0], op[1], op[2]); 7335 printf (" rsrc = 0x%x,", rsrc); 7336 printf (" rdst = 0x%x\n", rdst); 7337 } 7338 SYNTAX("adc %1, %0"); 7339 #line 491 "rx-decode.opc" 7340 ID(adc); SR(rsrc); DR(rdst); F_OSZC; 7341 7342 } 7343 break; 7344 } 7345 break; 7346 case 0x0f: 7347 GETBYTE (); 7348 switch (op[2] & 0x00) 7349 { 7350 case 0x00: 7351 { 7352 /** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */ 7353 #line 564 "rx-decode.opc" 7354 int rsrc AU = (op[2] >> 4) & 0x0f; 7355 #line 564 "rx-decode.opc" 7356 int rdst AU = op[2] & 0x0f; 7357 if (trace) 7358 { 7359 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7360 "/** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */", 7361 op[0], op[1], op[2]); 7362 printf (" rsrc = 0x%x,", rsrc); 7363 printf (" rdst = 0x%x\n", rdst); 7364 } 7365 SYNTAX("abs %1, %0"); 7366 #line 564 "rx-decode.opc" 7367 ID(abs); DR(rdst); SR(rsrc); F_OSZ_; 7368 7369 /*----------------------------------------------------------------------*/ 7370 /* MAX */ 7371 7372 } 7373 break; 7374 } 7375 break; 7376 case 0x10: 7377 GETBYTE (); 7378 switch (op[2] & 0x00) 7379 { 7380 case 0x00: 7381 op_semantics_48: 7382 { 7383 /** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */ 7384 #line 583 "rx-decode.opc" 7385 int ss AU = op[1] & 0x03; 7386 #line 583 "rx-decode.opc" 7387 int rsrc AU = (op[2] >> 4) & 0x0f; 7388 #line 583 "rx-decode.opc" 7389 int rdst AU = op[2] & 0x0f; 7390 if (trace) 7391 { 7392 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7393 "/** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */", 7394 op[0], op[1], op[2]); 7395 printf (" ss = 0x%x,", ss); 7396 printf (" rsrc = 0x%x,", rsrc); 7397 printf (" rdst = 0x%x\n", rdst); 7398 } 7399 SYNTAX("max %1%S1, %0"); 7400 #line 583 "rx-decode.opc" 7401 if (ss == 3 && rsrc == 0 && rdst == 0) 7402 { 7403 ID(nop3); 7404 SYNTAX("nop\t; max\tr0, r0"); 7405 } 7406 else 7407 { 7408 ID(max); SP(ss, rsrc); DR(rdst); 7409 } 7410 7411 } 7412 break; 7413 } 7414 break; 7415 case 0x11: 7416 GETBYTE (); 7417 switch (op[2] & 0x00) 7418 { 7419 case 0x00: 7420 goto op_semantics_48; 7421 break; 7422 } 7423 break; 7424 case 0x12: 7425 GETBYTE (); 7426 switch (op[2] & 0x00) 7427 { 7428 case 0x00: 7429 goto op_semantics_48; 7430 break; 7431 } 7432 break; 7433 case 0x13: 7434 GETBYTE (); 7435 switch (op[2] & 0x00) 7436 { 7437 case 0x00: 7438 goto op_semantics_48; 7439 break; 7440 } 7441 break; 7442 case 0x14: 7443 GETBYTE (); 7444 switch (op[2] & 0x00) 7445 { 7446 case 0x00: 7447 op_semantics_49: 7448 { 7449 /** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */ 7450 #line 603 "rx-decode.opc" 7451 int ss AU = op[1] & 0x03; 7452 #line 603 "rx-decode.opc" 7453 int rsrc AU = (op[2] >> 4) & 0x0f; 7454 #line 603 "rx-decode.opc" 7455 int rdst AU = op[2] & 0x0f; 7456 if (trace) 7457 { 7458 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7459 "/** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */", 7460 op[0], op[1], op[2]); 7461 printf (" ss = 0x%x,", ss); 7462 printf (" rsrc = 0x%x,", rsrc); 7463 printf (" rdst = 0x%x\n", rdst); 7464 } 7465 SYNTAX("min %1%S1, %0"); 7466 #line 603 "rx-decode.opc" 7467 ID(min); SP(ss, rsrc); DR(rdst); 7468 7469 } 7470 break; 7471 } 7472 break; 7473 case 0x15: 7474 GETBYTE (); 7475 switch (op[2] & 0x00) 7476 { 7477 case 0x00: 7478 goto op_semantics_49; 7479 break; 7480 } 7481 break; 7482 case 0x16: 7483 GETBYTE (); 7484 switch (op[2] & 0x00) 7485 { 7486 case 0x00: 7487 goto op_semantics_49; 7488 break; 7489 } 7490 break; 7491 case 0x17: 7492 GETBYTE (); 7493 switch (op[2] & 0x00) 7494 { 7495 case 0x00: 7496 goto op_semantics_49; 7497 break; 7498 } 7499 break; 7500 case 0x18: 7501 GETBYTE (); 7502 switch (op[2] & 0x00) 7503 { 7504 case 0x00: 7505 op_semantics_50: 7506 { 7507 /** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */ 7508 #line 661 "rx-decode.opc" 7509 int ss AU = op[1] & 0x03; 7510 #line 661 "rx-decode.opc" 7511 int rsrc AU = (op[2] >> 4) & 0x0f; 7512 #line 661 "rx-decode.opc" 7513 int rdst AU = op[2] & 0x0f; 7514 if (trace) 7515 { 7516 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7517 "/** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */", 7518 op[0], op[1], op[2]); 7519 printf (" ss = 0x%x,", ss); 7520 printf (" rsrc = 0x%x,", rsrc); 7521 printf (" rdst = 0x%x\n", rdst); 7522 } 7523 SYNTAX("emul %1%S1, %0"); 7524 #line 661 "rx-decode.opc" 7525 ID(emul); SP(ss, rsrc); DR(rdst); 7526 7527 } 7528 break; 7529 } 7530 break; 7531 case 0x19: 7532 GETBYTE (); 7533 switch (op[2] & 0x00) 7534 { 7535 case 0x00: 7536 goto op_semantics_50; 7537 break; 7538 } 7539 break; 7540 case 0x1a: 7541 GETBYTE (); 7542 switch (op[2] & 0x00) 7543 { 7544 case 0x00: 7545 goto op_semantics_50; 7546 break; 7547 } 7548 break; 7549 case 0x1b: 7550 GETBYTE (); 7551 switch (op[2] & 0x00) 7552 { 7553 case 0x00: 7554 goto op_semantics_50; 7555 break; 7556 } 7557 break; 7558 case 0x1c: 7559 GETBYTE (); 7560 switch (op[2] & 0x00) 7561 { 7562 case 0x00: 7563 op_semantics_51: 7564 { 7565 /** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */ 7566 #line 673 "rx-decode.opc" 7567 int ss AU = op[1] & 0x03; 7568 #line 673 "rx-decode.opc" 7569 int rsrc AU = (op[2] >> 4) & 0x0f; 7570 #line 673 "rx-decode.opc" 7571 int rdst AU = op[2] & 0x0f; 7572 if (trace) 7573 { 7574 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7575 "/** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */", 7576 op[0], op[1], op[2]); 7577 printf (" ss = 0x%x,", ss); 7578 printf (" rsrc = 0x%x,", rsrc); 7579 printf (" rdst = 0x%x\n", rdst); 7580 } 7581 SYNTAX("emulu %1%S1, %0"); 7582 #line 673 "rx-decode.opc" 7583 ID(emulu); SP(ss, rsrc); DR(rdst); 7584 7585 } 7586 break; 7587 } 7588 break; 7589 case 0x1d: 7590 GETBYTE (); 7591 switch (op[2] & 0x00) 7592 { 7593 case 0x00: 7594 goto op_semantics_51; 7595 break; 7596 } 7597 break; 7598 case 0x1e: 7599 GETBYTE (); 7600 switch (op[2] & 0x00) 7601 { 7602 case 0x00: 7603 goto op_semantics_51; 7604 break; 7605 } 7606 break; 7607 case 0x1f: 7608 GETBYTE (); 7609 switch (op[2] & 0x00) 7610 { 7611 case 0x00: 7612 goto op_semantics_51; 7613 break; 7614 } 7615 break; 7616 case 0x20: 7617 GETBYTE (); 7618 switch (op[2] & 0x00) 7619 { 7620 case 0x00: 7621 op_semantics_52: 7622 { 7623 /** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */ 7624 #line 685 "rx-decode.opc" 7625 int ss AU = op[1] & 0x03; 7626 #line 685 "rx-decode.opc" 7627 int rsrc AU = (op[2] >> 4) & 0x0f; 7628 #line 685 "rx-decode.opc" 7629 int rdst AU = op[2] & 0x0f; 7630 if (trace) 7631 { 7632 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7633 "/** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */", 7634 op[0], op[1], op[2]); 7635 printf (" ss = 0x%x,", ss); 7636 printf (" rsrc = 0x%x,", rsrc); 7637 printf (" rdst = 0x%x\n", rdst); 7638 } 7639 SYNTAX("div %1%S1, %0"); 7640 #line 685 "rx-decode.opc" 7641 ID(div); SP(ss, rsrc); DR(rdst); F_O___; 7642 7643 } 7644 break; 7645 } 7646 break; 7647 case 0x21: 7648 GETBYTE (); 7649 switch (op[2] & 0x00) 7650 { 7651 case 0x00: 7652 goto op_semantics_52; 7653 break; 7654 } 7655 break; 7656 case 0x22: 7657 GETBYTE (); 7658 switch (op[2] & 0x00) 7659 { 7660 case 0x00: 7661 goto op_semantics_52; 7662 break; 7663 } 7664 break; 7665 case 0x23: 7666 GETBYTE (); 7667 switch (op[2] & 0x00) 7668 { 7669 case 0x00: 7670 goto op_semantics_52; 7671 break; 7672 } 7673 break; 7674 case 0x24: 7675 GETBYTE (); 7676 switch (op[2] & 0x00) 7677 { 7678 case 0x00: 7679 op_semantics_53: 7680 { 7681 /** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */ 7682 #line 697 "rx-decode.opc" 7683 int ss AU = op[1] & 0x03; 7684 #line 697 "rx-decode.opc" 7685 int rsrc AU = (op[2] >> 4) & 0x0f; 7686 #line 697 "rx-decode.opc" 7687 int rdst AU = op[2] & 0x0f; 7688 if (trace) 7689 { 7690 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7691 "/** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */", 7692 op[0], op[1], op[2]); 7693 printf (" ss = 0x%x,", ss); 7694 printf (" rsrc = 0x%x,", rsrc); 7695 printf (" rdst = 0x%x\n", rdst); 7696 } 7697 SYNTAX("divu %1%S1, %0"); 7698 #line 697 "rx-decode.opc" 7699 ID(divu); SP(ss, rsrc); DR(rdst); F_O___; 7700 7701 } 7702 break; 7703 } 7704 break; 7705 case 0x25: 7706 GETBYTE (); 7707 switch (op[2] & 0x00) 7708 { 7709 case 0x00: 7710 goto op_semantics_53; 7711 break; 7712 } 7713 break; 7714 case 0x26: 7715 GETBYTE (); 7716 switch (op[2] & 0x00) 7717 { 7718 case 0x00: 7719 goto op_semantics_53; 7720 break; 7721 } 7722 break; 7723 case 0x27: 7724 GETBYTE (); 7725 switch (op[2] & 0x00) 7726 { 7727 case 0x00: 7728 goto op_semantics_53; 7729 break; 7730 } 7731 break; 7732 case 0x30: 7733 GETBYTE (); 7734 switch (op[2] & 0x00) 7735 { 7736 case 0x00: 7737 op_semantics_54: 7738 { 7739 /** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */ 7740 #line 470 "rx-decode.opc" 7741 int ss AU = op[1] & 0x03; 7742 #line 470 "rx-decode.opc" 7743 int rsrc AU = (op[2] >> 4) & 0x0f; 7744 #line 470 "rx-decode.opc" 7745 int rdst AU = op[2] & 0x0f; 7746 if (trace) 7747 { 7748 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7749 "/** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */", 7750 op[0], op[1], op[2]); 7751 printf (" ss = 0x%x,", ss); 7752 printf (" rsrc = 0x%x,", rsrc); 7753 printf (" rdst = 0x%x\n", rdst); 7754 } 7755 SYNTAX("tst %1%S1, %2"); 7756 #line 470 "rx-decode.opc" 7757 ID(and); SP(ss, rsrc); S2R(rdst); F__SZ_; 7758 7759 } 7760 break; 7761 } 7762 break; 7763 case 0x31: 7764 GETBYTE (); 7765 switch (op[2] & 0x00) 7766 { 7767 case 0x00: 7768 goto op_semantics_54; 7769 break; 7770 } 7771 break; 7772 case 0x32: 7773 GETBYTE (); 7774 switch (op[2] & 0x00) 7775 { 7776 case 0x00: 7777 goto op_semantics_54; 7778 break; 7779 } 7780 break; 7781 case 0x33: 7782 GETBYTE (); 7783 switch (op[2] & 0x00) 7784 { 7785 case 0x00: 7786 goto op_semantics_54; 7787 break; 7788 } 7789 break; 7790 case 0x34: 7791 GETBYTE (); 7792 switch (op[2] & 0x00) 7793 { 7794 case 0x00: 7795 op_semantics_55: 7796 { 7797 /** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */ 7798 #line 449 "rx-decode.opc" 7799 int ss AU = op[1] & 0x03; 7800 #line 449 "rx-decode.opc" 7801 int rsrc AU = (op[2] >> 4) & 0x0f; 7802 #line 449 "rx-decode.opc" 7803 int rdst AU = op[2] & 0x0f; 7804 if (trace) 7805 { 7806 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7807 "/** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */", 7808 op[0], op[1], op[2]); 7809 printf (" ss = 0x%x,", ss); 7810 printf (" rsrc = 0x%x,", rsrc); 7811 printf (" rdst = 0x%x\n", rdst); 7812 } 7813 SYNTAX("xor %1%S1, %0"); 7814 #line 449 "rx-decode.opc" 7815 ID(xor); SP(ss, rsrc); DR(rdst); F__SZ_; 7816 7817 } 7818 break; 7819 } 7820 break; 7821 case 0x35: 7822 GETBYTE (); 7823 switch (op[2] & 0x00) 7824 { 7825 case 0x00: 7826 goto op_semantics_55; 7827 break; 7828 } 7829 break; 7830 case 0x36: 7831 GETBYTE (); 7832 switch (op[2] & 0x00) 7833 { 7834 case 0x00: 7835 goto op_semantics_55; 7836 break; 7837 } 7838 break; 7839 case 0x37: 7840 GETBYTE (); 7841 switch (op[2] & 0x00) 7842 { 7843 case 0x00: 7844 goto op_semantics_55; 7845 break; 7846 } 7847 break; 7848 case 0x3b: 7849 GETBYTE (); 7850 switch (op[2] & 0x00) 7851 { 7852 case 0x00: 7853 { 7854 /** 1111 1100 0011 1011 rsrc rdst not %1, %0 */ 7855 #line 461 "rx-decode.opc" 7856 int rsrc AU = (op[2] >> 4) & 0x0f; 7857 #line 461 "rx-decode.opc" 7858 int rdst AU = op[2] & 0x0f; 7859 if (trace) 7860 { 7861 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7862 "/** 1111 1100 0011 1011 rsrc rdst not %1, %0 */", 7863 op[0], op[1], op[2]); 7864 printf (" rsrc = 0x%x,", rsrc); 7865 printf (" rdst = 0x%x\n", rdst); 7866 } 7867 SYNTAX("not %1, %0"); 7868 #line 461 "rx-decode.opc" 7869 ID(xor); DR(rdst); SR(rsrc); S2C(~0); F__SZ_; 7870 7871 /*----------------------------------------------------------------------*/ 7872 /* TST */ 7873 7874 } 7875 break; 7876 } 7877 break; 7878 case 0x40: 7879 GETBYTE (); 7880 switch (op[2] & 0x00) 7881 { 7882 case 0x00: 7883 op_semantics_56: 7884 { 7885 /** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */ 7886 #line 383 "rx-decode.opc" 7887 int ss AU = op[1] & 0x03; 7888 #line 383 "rx-decode.opc" 7889 int rsrc AU = (op[2] >> 4) & 0x0f; 7890 #line 383 "rx-decode.opc" 7891 int rdst AU = op[2] & 0x0f; 7892 if (trace) 7893 { 7894 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7895 "/** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */", 7896 op[0], op[1], op[2]); 7897 printf (" ss = 0x%x,", ss); 7898 printf (" rsrc = 0x%x,", rsrc); 7899 printf (" rdst = 0x%x\n", rdst); 7900 } 7901 SYNTAX("xchg %1%S1, %0"); 7902 #line 383 "rx-decode.opc" 7903 ID(xchg); DR(rdst); SP(ss, rsrc); 7904 7905 } 7906 break; 7907 } 7908 break; 7909 case 0x41: 7910 GETBYTE (); 7911 switch (op[2] & 0x00) 7912 { 7913 case 0x00: 7914 goto op_semantics_56; 7915 break; 7916 } 7917 break; 7918 case 0x42: 7919 GETBYTE (); 7920 switch (op[2] & 0x00) 7921 { 7922 case 0x00: 7923 goto op_semantics_56; 7924 break; 7925 } 7926 break; 7927 case 0x43: 7928 GETBYTE (); 7929 switch (op[2] & 0x00) 7930 { 7931 case 0x00: 7932 goto op_semantics_56; 7933 break; 7934 } 7935 break; 7936 case 0x44: 7937 GETBYTE (); 7938 switch (op[2] & 0x00) 7939 { 7940 case 0x00: 7941 op_semantics_57: 7942 { 7943 /** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */ 7944 #line 926 "rx-decode.opc" 7945 int sd AU = op[1] & 0x03; 7946 #line 926 "rx-decode.opc" 7947 int rsrc AU = (op[2] >> 4) & 0x0f; 7948 #line 926 "rx-decode.opc" 7949 int rdst AU = op[2] & 0x0f; 7950 if (trace) 7951 { 7952 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7953 "/** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */", 7954 op[0], op[1], op[2]); 7955 printf (" sd = 0x%x,", sd); 7956 printf (" rsrc = 0x%x,", rsrc); 7957 printf (" rdst = 0x%x\n", rdst); 7958 } 7959 SYNTAX("itof %1%S1, %0"); 7960 #line 926 "rx-decode.opc" 7961 ID(itof); DR (rdst); SP(sd, rsrc); F__SZ_; 7962 7963 } 7964 break; 7965 } 7966 break; 7967 case 0x45: 7968 GETBYTE (); 7969 switch (op[2] & 0x00) 7970 { 7971 case 0x00: 7972 goto op_semantics_57; 7973 break; 7974 } 7975 break; 7976 case 0x46: 7977 GETBYTE (); 7978 switch (op[2] & 0x00) 7979 { 7980 case 0x00: 7981 goto op_semantics_57; 7982 break; 7983 } 7984 break; 7985 case 0x47: 7986 GETBYTE (); 7987 switch (op[2] & 0x00) 7988 { 7989 case 0x00: 7990 goto op_semantics_57; 7991 break; 7992 } 7993 break; 7994 case 0x4b: 7995 GETBYTE (); 7996 switch (op[2] & 0x00) 7997 { 7998 case 0x00: 7999 { 8000 /** 1111 1100 0100 1011 rsrc rdst stz %1, %0 */ 8001 #line 1052 "rx-decode.opc" 8002 int rsrc AU = (op[2] >> 4) & 0x0f; 8003 #line 1052 "rx-decode.opc" 8004 int rdst AU = op[2] & 0x0f; 8005 if (trace) 8006 { 8007 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8008 "/** 1111 1100 0100 1011 rsrc rdst stz %1, %0 */", 8009 op[0], op[1], op[2]); 8010 printf (" rsrc = 0x%x,", rsrc); 8011 printf (" rdst = 0x%x\n", rdst); 8012 } 8013 SYNTAX("stz %1, %0"); 8014 #line 1052 "rx-decode.opc" 8015 ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_z); 8016 8017 } 8018 break; 8019 } 8020 break; 8021 case 0x4f: 8022 GETBYTE (); 8023 switch (op[2] & 0x00) 8024 { 8025 case 0x00: 8026 { 8027 /** 1111 1100 0100 1111 rsrc rdst stnz %1, %0 */ 8028 #line 1055 "rx-decode.opc" 8029 int rsrc AU = (op[2] >> 4) & 0x0f; 8030 #line 1055 "rx-decode.opc" 8031 int rdst AU = op[2] & 0x0f; 8032 if (trace) 8033 { 8034 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8035 "/** 1111 1100 0100 1111 rsrc rdst stnz %1, %0 */", 8036 op[0], op[1], op[2]); 8037 printf (" rsrc = 0x%x,", rsrc); 8038 printf (" rdst = 0x%x\n", rdst); 8039 } 8040 SYNTAX("stnz %1, %0"); 8041 #line 1055 "rx-decode.opc" 8042 ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_nz); 8043 8044 } 8045 break; 8046 } 8047 break; 8048 case 0x54: 8049 GETBYTE (); 8050 switch (op[2] & 0x00) 8051 { 8052 case 0x00: 8053 op_semantics_58: 8054 { 8055 /** 1111 1100 0101 01sd rsrc rdst utof %1%S1, %0 */ 8056 #line 1112 "rx-decode.opc" 8057 int sd AU = op[1] & 0x03; 8058 #line 1112 "rx-decode.opc" 8059 int rsrc AU = (op[2] >> 4) & 0x0f; 8060 #line 1112 "rx-decode.opc" 8061 int rdst AU = op[2] & 0x0f; 8062 if (trace) 8063 { 8064 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8065 "/** 1111 1100 0101 01sd rsrc rdst utof %1%S1, %0 */", 8066 op[0], op[1], op[2]); 8067 printf (" sd = 0x%x,", sd); 8068 printf (" rsrc = 0x%x,", rsrc); 8069 printf (" rdst = 0x%x\n", rdst); 8070 } 8071 SYNTAX("utof %1%S1, %0"); 8072 #line 1112 "rx-decode.opc" 8073 ID(utof); DR (rdst); SP(sd, rsrc); F__SZ_; 8074 8075 } 8076 break; 8077 } 8078 break; 8079 case 0x55: 8080 GETBYTE (); 8081 switch (op[2] & 0x00) 8082 { 8083 case 0x00: 8084 goto op_semantics_58; 8085 break; 8086 } 8087 break; 8088 case 0x56: 8089 GETBYTE (); 8090 switch (op[2] & 0x00) 8091 { 8092 case 0x00: 8093 goto op_semantics_58; 8094 break; 8095 } 8096 break; 8097 case 0x57: 8098 GETBYTE (); 8099 switch (op[2] & 0x00) 8100 { 8101 case 0x00: 8102 goto op_semantics_58; 8103 break; 8104 } 8105 break; 8106 case 0x60: 8107 GETBYTE (); 8108 switch (op[2] & 0x00) 8109 { 8110 case 0x00: 8111 op_semantics_59: 8112 { 8113 /** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */ 8114 #line 938 "rx-decode.opc" 8115 int sd AU = op[1] & 0x03; 8116 #line 938 "rx-decode.opc" 8117 int rdst AU = (op[2] >> 4) & 0x0f; 8118 #line 938 "rx-decode.opc" 8119 int rsrc AU = op[2] & 0x0f; 8120 if (trace) 8121 { 8122 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8123 "/** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */", 8124 op[0], op[1], op[2]); 8125 printf (" sd = 0x%x,", sd); 8126 printf (" rdst = 0x%x,", rdst); 8127 printf (" rsrc = 0x%x\n", rsrc); 8128 } 8129 SYNTAX("bset %1, %0%S0"); 8130 #line 938 "rx-decode.opc" 8131 ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____; 8132 if (sd == 3) /* bset reg,reg */ 8133 BWL(LSIZE); 8134 8135 } 8136 break; 8137 } 8138 break; 8139 case 0x61: 8140 GETBYTE (); 8141 switch (op[2] & 0x00) 8142 { 8143 case 0x00: 8144 goto op_semantics_59; 8145 break; 8146 } 8147 break; 8148 case 0x62: 8149 GETBYTE (); 8150 switch (op[2] & 0x00) 8151 { 8152 case 0x00: 8153 goto op_semantics_59; 8154 break; 8155 } 8156 break; 8157 case 0x63: 8158 GETBYTE (); 8159 switch (op[2] & 0x00) 8160 { 8161 case 0x00: 8162 goto op_semantics_59; 8163 break; 8164 } 8165 break; 8166 case 0x64: 8167 GETBYTE (); 8168 switch (op[2] & 0x00) 8169 { 8170 case 0x00: 8171 op_semantics_60: 8172 { 8173 /** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */ 8174 #line 950 "rx-decode.opc" 8175 int sd AU = op[1] & 0x03; 8176 #line 950 "rx-decode.opc" 8177 int rdst AU = (op[2] >> 4) & 0x0f; 8178 #line 950 "rx-decode.opc" 8179 int rsrc AU = op[2] & 0x0f; 8180 if (trace) 8181 { 8182 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8183 "/** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */", 8184 op[0], op[1], op[2]); 8185 printf (" sd = 0x%x,", sd); 8186 printf (" rdst = 0x%x,", rdst); 8187 printf (" rsrc = 0x%x\n", rsrc); 8188 } 8189 SYNTAX("bclr %1, %0%S0"); 8190 #line 950 "rx-decode.opc" 8191 ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____; 8192 if (sd == 3) /* bset reg,reg */ 8193 BWL(LSIZE); 8194 8195 } 8196 break; 8197 } 8198 break; 8199 case 0x65: 8200 GETBYTE (); 8201 switch (op[2] & 0x00) 8202 { 8203 case 0x00: 8204 goto op_semantics_60; 8205 break; 8206 } 8207 break; 8208 case 0x66: 8209 GETBYTE (); 8210 switch (op[2] & 0x00) 8211 { 8212 case 0x00: 8213 goto op_semantics_60; 8214 break; 8215 } 8216 break; 8217 case 0x67: 8218 GETBYTE (); 8219 switch (op[2] & 0x00) 8220 { 8221 case 0x00: 8222 goto op_semantics_60; 8223 break; 8224 } 8225 break; 8226 case 0x68: 8227 GETBYTE (); 8228 switch (op[2] & 0x00) 8229 { 8230 case 0x00: 8231 op_semantics_61: 8232 { 8233 /** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */ 8234 #line 962 "rx-decode.opc" 8235 int sd AU = op[1] & 0x03; 8236 #line 962 "rx-decode.opc" 8237 int rdst AU = (op[2] >> 4) & 0x0f; 8238 #line 962 "rx-decode.opc" 8239 int rsrc AU = op[2] & 0x0f; 8240 if (trace) 8241 { 8242 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8243 "/** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */", 8244 op[0], op[1], op[2]); 8245 printf (" sd = 0x%x,", sd); 8246 printf (" rdst = 0x%x,", rdst); 8247 printf (" rsrc = 0x%x\n", rsrc); 8248 } 8249 SYNTAX("btst %2, %1%S1"); 8250 #line 962 "rx-decode.opc" 8251 ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ZC; 8252 if (sd == 3) /* bset reg,reg */ 8253 BWL(LSIZE); 8254 8255 } 8256 break; 8257 } 8258 break; 8259 case 0x69: 8260 GETBYTE (); 8261 switch (op[2] & 0x00) 8262 { 8263 case 0x00: 8264 goto op_semantics_61; 8265 break; 8266 } 8267 break; 8268 case 0x6a: 8269 GETBYTE (); 8270 switch (op[2] & 0x00) 8271 { 8272 case 0x00: 8273 goto op_semantics_61; 8274 break; 8275 } 8276 break; 8277 case 0x6b: 8278 GETBYTE (); 8279 switch (op[2] & 0x00) 8280 { 8281 case 0x00: 8282 goto op_semantics_61; 8283 break; 8284 } 8285 break; 8286 case 0x6c: 8287 GETBYTE (); 8288 switch (op[2] & 0x00) 8289 { 8290 case 0x00: 8291 op_semantics_62: 8292 { 8293 /** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */ 8294 #line 974 "rx-decode.opc" 8295 int sd AU = op[1] & 0x03; 8296 #line 974 "rx-decode.opc" 8297 int rdst AU = (op[2] >> 4) & 0x0f; 8298 #line 974 "rx-decode.opc" 8299 int rsrc AU = op[2] & 0x0f; 8300 if (trace) 8301 { 8302 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8303 "/** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */", 8304 op[0], op[1], op[2]); 8305 printf (" sd = 0x%x,", sd); 8306 printf (" rdst = 0x%x,", rdst); 8307 printf (" rsrc = 0x%x\n", rsrc); 8308 } 8309 SYNTAX("bnot %1, %0%S0"); 8310 #line 974 "rx-decode.opc" 8311 ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); 8312 if (sd == 3) /* bset reg,reg */ 8313 BWL(LSIZE); 8314 8315 } 8316 break; 8317 } 8318 break; 8319 case 0x6d: 8320 GETBYTE (); 8321 switch (op[2] & 0x00) 8322 { 8323 case 0x00: 8324 goto op_semantics_62; 8325 break; 8326 } 8327 break; 8328 case 0x6e: 8329 GETBYTE (); 8330 switch (op[2] & 0x00) 8331 { 8332 case 0x00: 8333 goto op_semantics_62; 8334 break; 8335 } 8336 break; 8337 case 0x6f: 8338 GETBYTE (); 8339 switch (op[2] & 0x00) 8340 { 8341 case 0x00: 8342 goto op_semantics_62; 8343 break; 8344 } 8345 break; 8346 case 0x80: 8347 GETBYTE (); 8348 switch (op[2] & 0x00) 8349 { 8350 case 0x00: 8351 op_semantics_63: 8352 { 8353 /** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */ 8354 #line 905 "rx-decode.opc" 8355 int sd AU = op[1] & 0x03; 8356 #line 905 "rx-decode.opc" 8357 int rsrc AU = (op[2] >> 4) & 0x0f; 8358 #line 905 "rx-decode.opc" 8359 int rdst AU = op[2] & 0x0f; 8360 if (trace) 8361 { 8362 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8363 "/** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */", 8364 op[0], op[1], op[2]); 8365 printf (" sd = 0x%x,", sd); 8366 printf (" rsrc = 0x%x,", rsrc); 8367 printf (" rdst = 0x%x\n", rdst); 8368 } 8369 SYNTAX("fsub %1%S1, %0"); 8370 #line 905 "rx-decode.opc" 8371 ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8372 8373 } 8374 break; 8375 } 8376 break; 8377 case 0x81: 8378 GETBYTE (); 8379 switch (op[2] & 0x00) 8380 { 8381 case 0x00: 8382 goto op_semantics_63; 8383 break; 8384 } 8385 break; 8386 case 0x82: 8387 GETBYTE (); 8388 switch (op[2] & 0x00) 8389 { 8390 case 0x00: 8391 goto op_semantics_63; 8392 break; 8393 } 8394 break; 8395 case 0x83: 8396 GETBYTE (); 8397 switch (op[2] & 0x00) 8398 { 8399 case 0x00: 8400 goto op_semantics_63; 8401 break; 8402 } 8403 break; 8404 case 0x84: 8405 GETBYTE (); 8406 switch (op[2] & 0x00) 8407 { 8408 case 0x00: 8409 op_semantics_64: 8410 { 8411 /** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */ 8412 #line 899 "rx-decode.opc" 8413 int sd AU = op[1] & 0x03; 8414 #line 899 "rx-decode.opc" 8415 int rsrc AU = (op[2] >> 4) & 0x0f; 8416 #line 899 "rx-decode.opc" 8417 int rdst AU = op[2] & 0x0f; 8418 if (trace) 8419 { 8420 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8421 "/** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */", 8422 op[0], op[1], op[2]); 8423 printf (" sd = 0x%x,", sd); 8424 printf (" rsrc = 0x%x,", rsrc); 8425 printf (" rdst = 0x%x\n", rdst); 8426 } 8427 SYNTAX("fcmp %1%S1, %0"); 8428 #line 899 "rx-decode.opc" 8429 ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F_OSZ_; 8430 8431 } 8432 break; 8433 } 8434 break; 8435 case 0x85: 8436 GETBYTE (); 8437 switch (op[2] & 0x00) 8438 { 8439 case 0x00: 8440 goto op_semantics_64; 8441 break; 8442 } 8443 break; 8444 case 0x86: 8445 GETBYTE (); 8446 switch (op[2] & 0x00) 8447 { 8448 case 0x00: 8449 goto op_semantics_64; 8450 break; 8451 } 8452 break; 8453 case 0x87: 8454 GETBYTE (); 8455 switch (op[2] & 0x00) 8456 { 8457 case 0x00: 8458 goto op_semantics_64; 8459 break; 8460 } 8461 break; 8462 case 0x88: 8463 GETBYTE (); 8464 switch (op[2] & 0x00) 8465 { 8466 case 0x00: 8467 op_semantics_65: 8468 { 8469 /** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */ 8470 #line 893 "rx-decode.opc" 8471 int sd AU = op[1] & 0x03; 8472 #line 893 "rx-decode.opc" 8473 int rsrc AU = (op[2] >> 4) & 0x0f; 8474 #line 893 "rx-decode.opc" 8475 int rdst AU = op[2] & 0x0f; 8476 if (trace) 8477 { 8478 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8479 "/** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */", 8480 op[0], op[1], op[2]); 8481 printf (" sd = 0x%x,", sd); 8482 printf (" rsrc = 0x%x,", rsrc); 8483 printf (" rdst = 0x%x\n", rdst); 8484 } 8485 SYNTAX("fadd %1%S1, %0"); 8486 #line 893 "rx-decode.opc" 8487 ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8488 8489 } 8490 break; 8491 } 8492 break; 8493 case 0x89: 8494 GETBYTE (); 8495 switch (op[2] & 0x00) 8496 { 8497 case 0x00: 8498 goto op_semantics_65; 8499 break; 8500 } 8501 break; 8502 case 0x8a: 8503 GETBYTE (); 8504 switch (op[2] & 0x00) 8505 { 8506 case 0x00: 8507 goto op_semantics_65; 8508 break; 8509 } 8510 break; 8511 case 0x8b: 8512 GETBYTE (); 8513 switch (op[2] & 0x00) 8514 { 8515 case 0x00: 8516 goto op_semantics_65; 8517 break; 8518 } 8519 break; 8520 case 0x8c: 8521 GETBYTE (); 8522 switch (op[2] & 0x00) 8523 { 8524 case 0x00: 8525 op_semantics_66: 8526 { 8527 /** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */ 8528 #line 914 "rx-decode.opc" 8529 int sd AU = op[1] & 0x03; 8530 #line 914 "rx-decode.opc" 8531 int rsrc AU = (op[2] >> 4) & 0x0f; 8532 #line 914 "rx-decode.opc" 8533 int rdst AU = op[2] & 0x0f; 8534 if (trace) 8535 { 8536 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8537 "/** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */", 8538 op[0], op[1], op[2]); 8539 printf (" sd = 0x%x,", sd); 8540 printf (" rsrc = 0x%x,", rsrc); 8541 printf (" rdst = 0x%x\n", rdst); 8542 } 8543 SYNTAX("fmul %1%S1, %0"); 8544 #line 914 "rx-decode.opc" 8545 ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8546 8547 } 8548 break; 8549 } 8550 break; 8551 case 0x8d: 8552 GETBYTE (); 8553 switch (op[2] & 0x00) 8554 { 8555 case 0x00: 8556 goto op_semantics_66; 8557 break; 8558 } 8559 break; 8560 case 0x8e: 8561 GETBYTE (); 8562 switch (op[2] & 0x00) 8563 { 8564 case 0x00: 8565 goto op_semantics_66; 8566 break; 8567 } 8568 break; 8569 case 0x8f: 8570 GETBYTE (); 8571 switch (op[2] & 0x00) 8572 { 8573 case 0x00: 8574 goto op_semantics_66; 8575 break; 8576 } 8577 break; 8578 case 0x90: 8579 GETBYTE (); 8580 switch (op[2] & 0x00) 8581 { 8582 case 0x00: 8583 op_semantics_67: 8584 { 8585 /** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */ 8586 #line 920 "rx-decode.opc" 8587 int sd AU = op[1] & 0x03; 8588 #line 920 "rx-decode.opc" 8589 int rsrc AU = (op[2] >> 4) & 0x0f; 8590 #line 920 "rx-decode.opc" 8591 int rdst AU = op[2] & 0x0f; 8592 if (trace) 8593 { 8594 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8595 "/** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */", 8596 op[0], op[1], op[2]); 8597 printf (" sd = 0x%x,", sd); 8598 printf (" rsrc = 0x%x,", rsrc); 8599 printf (" rdst = 0x%x\n", rdst); 8600 } 8601 SYNTAX("fdiv %1%S1, %0"); 8602 #line 920 "rx-decode.opc" 8603 ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8604 8605 } 8606 break; 8607 } 8608 break; 8609 case 0x91: 8610 GETBYTE (); 8611 switch (op[2] & 0x00) 8612 { 8613 case 0x00: 8614 goto op_semantics_67; 8615 break; 8616 } 8617 break; 8618 case 0x92: 8619 GETBYTE (); 8620 switch (op[2] & 0x00) 8621 { 8622 case 0x00: 8623 goto op_semantics_67; 8624 break; 8625 } 8626 break; 8627 case 0x93: 8628 GETBYTE (); 8629 switch (op[2] & 0x00) 8630 { 8631 case 0x00: 8632 goto op_semantics_67; 8633 break; 8634 } 8635 break; 8636 case 0x94: 8637 GETBYTE (); 8638 switch (op[2] & 0x00) 8639 { 8640 case 0x00: 8641 op_semantics_68: 8642 { 8643 /** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */ 8644 #line 908 "rx-decode.opc" 8645 int sd AU = op[1] & 0x03; 8646 #line 908 "rx-decode.opc" 8647 int rsrc AU = (op[2] >> 4) & 0x0f; 8648 #line 908 "rx-decode.opc" 8649 int rdst AU = op[2] & 0x0f; 8650 if (trace) 8651 { 8652 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8653 "/** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */", 8654 op[0], op[1], op[2]); 8655 printf (" sd = 0x%x,", sd); 8656 printf (" rsrc = 0x%x,", rsrc); 8657 printf (" rdst = 0x%x\n", rdst); 8658 } 8659 SYNTAX("ftoi %1%S1, %0"); 8660 #line 908 "rx-decode.opc" 8661 ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8662 8663 } 8664 break; 8665 } 8666 break; 8667 case 0x95: 8668 GETBYTE (); 8669 switch (op[2] & 0x00) 8670 { 8671 case 0x00: 8672 goto op_semantics_68; 8673 break; 8674 } 8675 break; 8676 case 0x96: 8677 GETBYTE (); 8678 switch (op[2] & 0x00) 8679 { 8680 case 0x00: 8681 goto op_semantics_68; 8682 break; 8683 } 8684 break; 8685 case 0x97: 8686 GETBYTE (); 8687 switch (op[2] & 0x00) 8688 { 8689 case 0x00: 8690 goto op_semantics_68; 8691 break; 8692 } 8693 break; 8694 case 0x98: 8695 GETBYTE (); 8696 switch (op[2] & 0x00) 8697 { 8698 case 0x00: 8699 op_semantics_69: 8700 { 8701 /** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */ 8702 #line 923 "rx-decode.opc" 8703 int sd AU = op[1] & 0x03; 8704 #line 923 "rx-decode.opc" 8705 int rsrc AU = (op[2] >> 4) & 0x0f; 8706 #line 923 "rx-decode.opc" 8707 int rdst AU = op[2] & 0x0f; 8708 if (trace) 8709 { 8710 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8711 "/** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */", 8712 op[0], op[1], op[2]); 8713 printf (" sd = 0x%x,", sd); 8714 printf (" rsrc = 0x%x,", rsrc); 8715 printf (" rdst = 0x%x\n", rdst); 8716 } 8717 SYNTAX("round %1%S1, %0"); 8718 #line 923 "rx-decode.opc" 8719 ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8720 8721 } 8722 break; 8723 } 8724 break; 8725 case 0x99: 8726 GETBYTE (); 8727 switch (op[2] & 0x00) 8728 { 8729 case 0x00: 8730 goto op_semantics_69; 8731 break; 8732 } 8733 break; 8734 case 0x9a: 8735 GETBYTE (); 8736 switch (op[2] & 0x00) 8737 { 8738 case 0x00: 8739 goto op_semantics_69; 8740 break; 8741 } 8742 break; 8743 case 0x9b: 8744 GETBYTE (); 8745 switch (op[2] & 0x00) 8746 { 8747 case 0x00: 8748 goto op_semantics_69; 8749 break; 8750 } 8751 break; 8752 case 0xa0: 8753 GETBYTE (); 8754 switch (op[2] & 0x00) 8755 { 8756 case 0x00: 8757 op_semantics_70: 8758 { 8759 /** 1111 1100 1010 00sd rsrc rdst fsqrt %1%S1, %0 */ 8760 #line 1106 "rx-decode.opc" 8761 int sd AU = op[1] & 0x03; 8762 #line 1106 "rx-decode.opc" 8763 int rsrc AU = (op[2] >> 4) & 0x0f; 8764 #line 1106 "rx-decode.opc" 8765 int rdst AU = op[2] & 0x0f; 8766 if (trace) 8767 { 8768 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8769 "/** 1111 1100 1010 00sd rsrc rdst fsqrt %1%S1, %0 */", 8770 op[0], op[1], op[2]); 8771 printf (" sd = 0x%x,", sd); 8772 printf (" rsrc = 0x%x,", rsrc); 8773 printf (" rdst = 0x%x\n", rdst); 8774 } 8775 SYNTAX("fsqrt %1%S1, %0"); 8776 #line 1106 "rx-decode.opc" 8777 ID(fsqrt); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8778 8779 } 8780 break; 8781 } 8782 break; 8783 case 0xa1: 8784 GETBYTE (); 8785 switch (op[2] & 0x00) 8786 { 8787 case 0x00: 8788 goto op_semantics_70; 8789 break; 8790 } 8791 break; 8792 case 0xa2: 8793 GETBYTE (); 8794 switch (op[2] & 0x00) 8795 { 8796 case 0x00: 8797 goto op_semantics_70; 8798 break; 8799 } 8800 break; 8801 case 0xa3: 8802 GETBYTE (); 8803 switch (op[2] & 0x00) 8804 { 8805 case 0x00: 8806 goto op_semantics_70; 8807 break; 8808 } 8809 break; 8810 case 0xa4: 8811 GETBYTE (); 8812 switch (op[2] & 0x00) 8813 { 8814 case 0x00: 8815 op_semantics_71: 8816 { 8817 /** 1111 1100 1010 01sd rsrc rdst ftou %1%S1, %0 */ 8818 #line 1109 "rx-decode.opc" 8819 int sd AU = op[1] & 0x03; 8820 #line 1109 "rx-decode.opc" 8821 int rsrc AU = (op[2] >> 4) & 0x0f; 8822 #line 1109 "rx-decode.opc" 8823 int rdst AU = op[2] & 0x0f; 8824 if (trace) 8825 { 8826 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8827 "/** 1111 1100 1010 01sd rsrc rdst ftou %1%S1, %0 */", 8828 op[0], op[1], op[2]); 8829 printf (" sd = 0x%x,", sd); 8830 printf (" rsrc = 0x%x,", rsrc); 8831 printf (" rdst = 0x%x\n", rdst); 8832 } 8833 SYNTAX("ftou %1%S1, %0"); 8834 #line 1109 "rx-decode.opc" 8835 ID(ftou); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8836 8837 } 8838 break; 8839 } 8840 break; 8841 case 0xa5: 8842 GETBYTE (); 8843 switch (op[2] & 0x00) 8844 { 8845 case 0x00: 8846 goto op_semantics_71; 8847 break; 8848 } 8849 break; 8850 case 0xa6: 8851 GETBYTE (); 8852 switch (op[2] & 0x00) 8853 { 8854 case 0x00: 8855 goto op_semantics_71; 8856 break; 8857 } 8858 break; 8859 case 0xa7: 8860 GETBYTE (); 8861 switch (op[2] & 0x00) 8862 { 8863 case 0x00: 8864 goto op_semantics_71; 8865 break; 8866 } 8867 break; 8868 case 0xd0: 8869 GETBYTE (); 8870 switch (op[2] & 0x00) 8871 { 8872 case 0x00: 8873 op_semantics_72: 8874 { 8875 /** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */ 8876 #line 1040 "rx-decode.opc" 8877 int sz AU = (op[1] >> 2) & 0x03; 8878 #line 1040 "rx-decode.opc" 8879 int sd AU = op[1] & 0x03; 8880 #line 1040 "rx-decode.opc" 8881 int rdst AU = (op[2] >> 4) & 0x0f; 8882 #line 1040 "rx-decode.opc" 8883 int cond AU = op[2] & 0x0f; 8884 if (trace) 8885 { 8886 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8887 "/** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */", 8888 op[0], op[1], op[2]); 8889 printf (" sz = 0x%x,", sz); 8890 printf (" sd = 0x%x,", sd); 8891 printf (" rdst = 0x%x,", rdst); 8892 printf (" cond = 0x%x\n", cond); 8893 } 8894 SYNTAX("sc%1%s %0"); 8895 #line 1040 "rx-decode.opc" 8896 ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond); 8897 8898 /*----------------------------------------------------------------------*/ 8899 /* RXv2 enhanced */ 8900 8901 } 8902 break; 8903 } 8904 break; 8905 case 0xd1: 8906 GETBYTE (); 8907 switch (op[2] & 0x00) 8908 { 8909 case 0x00: 8910 goto op_semantics_72; 8911 break; 8912 } 8913 break; 8914 case 0xd2: 8915 GETBYTE (); 8916 switch (op[2] & 0x00) 8917 { 8918 case 0x00: 8919 goto op_semantics_72; 8920 break; 8921 } 8922 break; 8923 case 0xd3: 8924 GETBYTE (); 8925 switch (op[2] & 0x00) 8926 { 8927 case 0x00: 8928 goto op_semantics_72; 8929 break; 8930 } 8931 break; 8932 case 0xd4: 8933 GETBYTE (); 8934 switch (op[2] & 0x00) 8935 { 8936 case 0x00: 8937 goto op_semantics_72; 8938 break; 8939 } 8940 break; 8941 case 0xd5: 8942 GETBYTE (); 8943 switch (op[2] & 0x00) 8944 { 8945 case 0x00: 8946 goto op_semantics_72; 8947 break; 8948 } 8949 break; 8950 case 0xd6: 8951 GETBYTE (); 8952 switch (op[2] & 0x00) 8953 { 8954 case 0x00: 8955 goto op_semantics_72; 8956 break; 8957 } 8958 break; 8959 case 0xd7: 8960 GETBYTE (); 8961 switch (op[2] & 0x00) 8962 { 8963 case 0x00: 8964 goto op_semantics_72; 8965 break; 8966 } 8967 break; 8968 case 0xd8: 8969 GETBYTE (); 8970 switch (op[2] & 0x00) 8971 { 8972 case 0x00: 8973 goto op_semantics_72; 8974 break; 8975 } 8976 break; 8977 case 0xd9: 8978 GETBYTE (); 8979 switch (op[2] & 0x00) 8980 { 8981 case 0x00: 8982 goto op_semantics_72; 8983 break; 8984 } 8985 break; 8986 case 0xda: 8987 GETBYTE (); 8988 switch (op[2] & 0x00) 8989 { 8990 case 0x00: 8991 goto op_semantics_72; 8992 break; 8993 } 8994 break; 8995 case 0xdb: 8996 GETBYTE (); 8997 switch (op[2] & 0x00) 8998 { 8999 case 0x00: 9000 goto op_semantics_72; 9001 break; 9002 } 9003 break; 9004 case 0xe0: 9005 GETBYTE (); 9006 switch (op[2] & 0x0f) 9007 { 9008 case 0x00: 9009 case 0x01: 9010 case 0x02: 9011 case 0x03: 9012 case 0x04: 9013 case 0x05: 9014 case 0x06: 9015 case 0x07: 9016 case 0x08: 9017 case 0x09: 9018 case 0x0a: 9019 case 0x0b: 9020 case 0x0c: 9021 case 0x0d: 9022 case 0x0e: 9023 op_semantics_73: 9024 { 9025 /** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */ 9026 #line 983 "rx-decode.opc" 9027 int bit AU = (op[1] >> 2) & 0x07; 9028 #line 983 "rx-decode.opc" 9029 int sd AU = op[1] & 0x03; 9030 #line 983 "rx-decode.opc" 9031 int rdst AU = (op[2] >> 4) & 0x0f; 9032 #line 983 "rx-decode.opc" 9033 int cond AU = op[2] & 0x0f; 9034 if (trace) 9035 { 9036 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9037 "/** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */", 9038 op[0], op[1], op[2]); 9039 printf (" bit = 0x%x,", bit); 9040 printf (" sd = 0x%x,", sd); 9041 printf (" rdst = 0x%x,", rdst); 9042 printf (" cond = 0x%x\n", cond); 9043 } 9044 SYNTAX("bm%2 #%1, %0%S0"); 9045 #line 983 "rx-decode.opc" 9046 ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE); 9047 9048 } 9049 break; 9050 case 0x0f: 9051 op_semantics_74: 9052 { 9053 /** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */ 9054 #line 971 "rx-decode.opc" 9055 int bit AU = (op[1] >> 2) & 0x07; 9056 #line 971 "rx-decode.opc" 9057 int sd AU = op[1] & 0x03; 9058 #line 971 "rx-decode.opc" 9059 int rdst AU = (op[2] >> 4) & 0x0f; 9060 if (trace) 9061 { 9062 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9063 "/** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */", 9064 op[0], op[1], op[2]); 9065 printf (" bit = 0x%x,", bit); 9066 printf (" sd = 0x%x,", sd); 9067 printf (" rdst = 0x%x\n", rdst); 9068 } 9069 SYNTAX("bnot #%1, %0%S0"); 9070 #line 971 "rx-decode.opc" 9071 ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); 9072 9073 } 9074 break; 9075 } 9076 break; 9077 case 0xe1: 9078 GETBYTE (); 9079 switch (op[2] & 0x0f) 9080 { 9081 case 0x00: 9082 case 0x01: 9083 case 0x02: 9084 case 0x03: 9085 case 0x04: 9086 case 0x05: 9087 case 0x06: 9088 case 0x07: 9089 case 0x08: 9090 case 0x09: 9091 case 0x0a: 9092 case 0x0b: 9093 case 0x0c: 9094 case 0x0d: 9095 case 0x0e: 9096 goto op_semantics_73; 9097 break; 9098 case 0x0f: 9099 goto op_semantics_74; 9100 break; 9101 } 9102 break; 9103 case 0xe2: 9104 GETBYTE (); 9105 switch (op[2] & 0x0f) 9106 { 9107 case 0x00: 9108 case 0x01: 9109 case 0x02: 9110 case 0x03: 9111 case 0x04: 9112 case 0x05: 9113 case 0x06: 9114 case 0x07: 9115 case 0x08: 9116 case 0x09: 9117 case 0x0a: 9118 case 0x0b: 9119 case 0x0c: 9120 case 0x0d: 9121 case 0x0e: 9122 goto op_semantics_73; 9123 break; 9124 case 0x0f: 9125 goto op_semantics_74; 9126 break; 9127 } 9128 break; 9129 case 0xe3: 9130 GETBYTE (); 9131 switch (op[2] & 0x0f) 9132 { 9133 case 0x00: 9134 case 0x01: 9135 case 0x02: 9136 case 0x03: 9137 case 0x04: 9138 case 0x05: 9139 case 0x06: 9140 case 0x07: 9141 case 0x08: 9142 case 0x09: 9143 case 0x0a: 9144 case 0x0b: 9145 case 0x0c: 9146 case 0x0d: 9147 case 0x0e: 9148 goto op_semantics_73; 9149 break; 9150 case 0x0f: 9151 goto op_semantics_74; 9152 break; 9153 } 9154 break; 9155 case 0xe4: 9156 GETBYTE (); 9157 switch (op[2] & 0x0f) 9158 { 9159 case 0x00: 9160 case 0x01: 9161 case 0x02: 9162 case 0x03: 9163 case 0x04: 9164 case 0x05: 9165 case 0x06: 9166 case 0x07: 9167 case 0x08: 9168 case 0x09: 9169 case 0x0a: 9170 case 0x0b: 9171 case 0x0c: 9172 case 0x0d: 9173 case 0x0e: 9174 goto op_semantics_73; 9175 break; 9176 case 0x0f: 9177 goto op_semantics_74; 9178 break; 9179 } 9180 break; 9181 case 0xe5: 9182 GETBYTE (); 9183 switch (op[2] & 0x0f) 9184 { 9185 case 0x00: 9186 case 0x01: 9187 case 0x02: 9188 case 0x03: 9189 case 0x04: 9190 case 0x05: 9191 case 0x06: 9192 case 0x07: 9193 case 0x08: 9194 case 0x09: 9195 case 0x0a: 9196 case 0x0b: 9197 case 0x0c: 9198 case 0x0d: 9199 case 0x0e: 9200 goto op_semantics_73; 9201 break; 9202 case 0x0f: 9203 goto op_semantics_74; 9204 break; 9205 } 9206 break; 9207 case 0xe6: 9208 GETBYTE (); 9209 switch (op[2] & 0x0f) 9210 { 9211 case 0x00: 9212 case 0x01: 9213 case 0x02: 9214 case 0x03: 9215 case 0x04: 9216 case 0x05: 9217 case 0x06: 9218 case 0x07: 9219 case 0x08: 9220 case 0x09: 9221 case 0x0a: 9222 case 0x0b: 9223 case 0x0c: 9224 case 0x0d: 9225 case 0x0e: 9226 goto op_semantics_73; 9227 break; 9228 case 0x0f: 9229 goto op_semantics_74; 9230 break; 9231 } 9232 break; 9233 case 0xe7: 9234 GETBYTE (); 9235 switch (op[2] & 0x0f) 9236 { 9237 case 0x00: 9238 case 0x01: 9239 case 0x02: 9240 case 0x03: 9241 case 0x04: 9242 case 0x05: 9243 case 0x06: 9244 case 0x07: 9245 case 0x08: 9246 case 0x09: 9247 case 0x0a: 9248 case 0x0b: 9249 case 0x0c: 9250 case 0x0d: 9251 case 0x0e: 9252 goto op_semantics_73; 9253 break; 9254 case 0x0f: 9255 goto op_semantics_74; 9256 break; 9257 } 9258 break; 9259 case 0xe8: 9260 GETBYTE (); 9261 switch (op[2] & 0x0f) 9262 { 9263 case 0x00: 9264 case 0x01: 9265 case 0x02: 9266 case 0x03: 9267 case 0x04: 9268 case 0x05: 9269 case 0x06: 9270 case 0x07: 9271 case 0x08: 9272 case 0x09: 9273 case 0x0a: 9274 case 0x0b: 9275 case 0x0c: 9276 case 0x0d: 9277 case 0x0e: 9278 goto op_semantics_73; 9279 break; 9280 case 0x0f: 9281 goto op_semantics_74; 9282 break; 9283 } 9284 break; 9285 case 0xe9: 9286 GETBYTE (); 9287 switch (op[2] & 0x0f) 9288 { 9289 case 0x00: 9290 case 0x01: 9291 case 0x02: 9292 case 0x03: 9293 case 0x04: 9294 case 0x05: 9295 case 0x06: 9296 case 0x07: 9297 case 0x08: 9298 case 0x09: 9299 case 0x0a: 9300 case 0x0b: 9301 case 0x0c: 9302 case 0x0d: 9303 case 0x0e: 9304 goto op_semantics_73; 9305 break; 9306 case 0x0f: 9307 goto op_semantics_74; 9308 break; 9309 } 9310 break; 9311 case 0xea: 9312 GETBYTE (); 9313 switch (op[2] & 0x0f) 9314 { 9315 case 0x00: 9316 case 0x01: 9317 case 0x02: 9318 case 0x03: 9319 case 0x04: 9320 case 0x05: 9321 case 0x06: 9322 case 0x07: 9323 case 0x08: 9324 case 0x09: 9325 case 0x0a: 9326 case 0x0b: 9327 case 0x0c: 9328 case 0x0d: 9329 case 0x0e: 9330 goto op_semantics_73; 9331 break; 9332 case 0x0f: 9333 goto op_semantics_74; 9334 break; 9335 } 9336 break; 9337 case 0xeb: 9338 GETBYTE (); 9339 switch (op[2] & 0x0f) 9340 { 9341 case 0x00: 9342 case 0x01: 9343 case 0x02: 9344 case 0x03: 9345 case 0x04: 9346 case 0x05: 9347 case 0x06: 9348 case 0x07: 9349 case 0x08: 9350 case 0x09: 9351 case 0x0a: 9352 case 0x0b: 9353 case 0x0c: 9354 case 0x0d: 9355 case 0x0e: 9356 goto op_semantics_73; 9357 break; 9358 case 0x0f: 9359 goto op_semantics_74; 9360 break; 9361 } 9362 break; 9363 case 0xec: 9364 GETBYTE (); 9365 switch (op[2] & 0x0f) 9366 { 9367 case 0x00: 9368 case 0x01: 9369 case 0x02: 9370 case 0x03: 9371 case 0x04: 9372 case 0x05: 9373 case 0x06: 9374 case 0x07: 9375 case 0x08: 9376 case 0x09: 9377 case 0x0a: 9378 case 0x0b: 9379 case 0x0c: 9380 case 0x0d: 9381 case 0x0e: 9382 goto op_semantics_73; 9383 break; 9384 case 0x0f: 9385 goto op_semantics_74; 9386 break; 9387 } 9388 break; 9389 case 0xed: 9390 GETBYTE (); 9391 switch (op[2] & 0x0f) 9392 { 9393 case 0x00: 9394 case 0x01: 9395 case 0x02: 9396 case 0x03: 9397 case 0x04: 9398 case 0x05: 9399 case 0x06: 9400 case 0x07: 9401 case 0x08: 9402 case 0x09: 9403 case 0x0a: 9404 case 0x0b: 9405 case 0x0c: 9406 case 0x0d: 9407 case 0x0e: 9408 goto op_semantics_73; 9409 break; 9410 case 0x0f: 9411 goto op_semantics_74; 9412 break; 9413 } 9414 break; 9415 case 0xee: 9416 GETBYTE (); 9417 switch (op[2] & 0x0f) 9418 { 9419 case 0x00: 9420 case 0x01: 9421 case 0x02: 9422 case 0x03: 9423 case 0x04: 9424 case 0x05: 9425 case 0x06: 9426 case 0x07: 9427 case 0x08: 9428 case 0x09: 9429 case 0x0a: 9430 case 0x0b: 9431 case 0x0c: 9432 case 0x0d: 9433 case 0x0e: 9434 goto op_semantics_73; 9435 break; 9436 case 0x0f: 9437 goto op_semantics_74; 9438 break; 9439 } 9440 break; 9441 case 0xef: 9442 GETBYTE (); 9443 switch (op[2] & 0x0f) 9444 { 9445 case 0x00: 9446 case 0x01: 9447 case 0x02: 9448 case 0x03: 9449 case 0x04: 9450 case 0x05: 9451 case 0x06: 9452 case 0x07: 9453 case 0x08: 9454 case 0x09: 9455 case 0x0a: 9456 case 0x0b: 9457 case 0x0c: 9458 case 0x0d: 9459 case 0x0e: 9460 goto op_semantics_73; 9461 break; 9462 case 0x0f: 9463 goto op_semantics_74; 9464 break; 9465 } 9466 break; 9467 case 0xf0: 9468 GETBYTE (); 9469 switch (op[2] & 0x0f) 9470 { 9471 case 0x00: 9472 case 0x01: 9473 case 0x02: 9474 case 0x03: 9475 case 0x04: 9476 case 0x05: 9477 case 0x06: 9478 case 0x07: 9479 case 0x08: 9480 case 0x09: 9481 case 0x0a: 9482 case 0x0b: 9483 case 0x0c: 9484 case 0x0d: 9485 case 0x0e: 9486 goto op_semantics_73; 9487 break; 9488 case 0x0f: 9489 goto op_semantics_74; 9490 break; 9491 } 9492 break; 9493 case 0xf1: 9494 GETBYTE (); 9495 switch (op[2] & 0x0f) 9496 { 9497 case 0x00: 9498 case 0x01: 9499 case 0x02: 9500 case 0x03: 9501 case 0x04: 9502 case 0x05: 9503 case 0x06: 9504 case 0x07: 9505 case 0x08: 9506 case 0x09: 9507 case 0x0a: 9508 case 0x0b: 9509 case 0x0c: 9510 case 0x0d: 9511 case 0x0e: 9512 goto op_semantics_73; 9513 break; 9514 case 0x0f: 9515 goto op_semantics_74; 9516 break; 9517 } 9518 break; 9519 case 0xf2: 9520 GETBYTE (); 9521 switch (op[2] & 0x0f) 9522 { 9523 case 0x00: 9524 case 0x01: 9525 case 0x02: 9526 case 0x03: 9527 case 0x04: 9528 case 0x05: 9529 case 0x06: 9530 case 0x07: 9531 case 0x08: 9532 case 0x09: 9533 case 0x0a: 9534 case 0x0b: 9535 case 0x0c: 9536 case 0x0d: 9537 case 0x0e: 9538 goto op_semantics_73; 9539 break; 9540 case 0x0f: 9541 goto op_semantics_74; 9542 break; 9543 } 9544 break; 9545 case 0xf3: 9546 GETBYTE (); 9547 switch (op[2] & 0x0f) 9548 { 9549 case 0x00: 9550 case 0x01: 9551 case 0x02: 9552 case 0x03: 9553 case 0x04: 9554 case 0x05: 9555 case 0x06: 9556 case 0x07: 9557 case 0x08: 9558 case 0x09: 9559 case 0x0a: 9560 case 0x0b: 9561 case 0x0c: 9562 case 0x0d: 9563 case 0x0e: 9564 goto op_semantics_73; 9565 break; 9566 case 0x0f: 9567 goto op_semantics_74; 9568 break; 9569 } 9570 break; 9571 case 0xf4: 9572 GETBYTE (); 9573 switch (op[2] & 0x0f) 9574 { 9575 case 0x00: 9576 case 0x01: 9577 case 0x02: 9578 case 0x03: 9579 case 0x04: 9580 case 0x05: 9581 case 0x06: 9582 case 0x07: 9583 case 0x08: 9584 case 0x09: 9585 case 0x0a: 9586 case 0x0b: 9587 case 0x0c: 9588 case 0x0d: 9589 case 0x0e: 9590 goto op_semantics_73; 9591 break; 9592 case 0x0f: 9593 goto op_semantics_74; 9594 break; 9595 } 9596 break; 9597 case 0xf5: 9598 GETBYTE (); 9599 switch (op[2] & 0x0f) 9600 { 9601 case 0x00: 9602 case 0x01: 9603 case 0x02: 9604 case 0x03: 9605 case 0x04: 9606 case 0x05: 9607 case 0x06: 9608 case 0x07: 9609 case 0x08: 9610 case 0x09: 9611 case 0x0a: 9612 case 0x0b: 9613 case 0x0c: 9614 case 0x0d: 9615 case 0x0e: 9616 goto op_semantics_73; 9617 break; 9618 case 0x0f: 9619 goto op_semantics_74; 9620 break; 9621 } 9622 break; 9623 case 0xf6: 9624 GETBYTE (); 9625 switch (op[2] & 0x0f) 9626 { 9627 case 0x00: 9628 case 0x01: 9629 case 0x02: 9630 case 0x03: 9631 case 0x04: 9632 case 0x05: 9633 case 0x06: 9634 case 0x07: 9635 case 0x08: 9636 case 0x09: 9637 case 0x0a: 9638 case 0x0b: 9639 case 0x0c: 9640 case 0x0d: 9641 case 0x0e: 9642 goto op_semantics_73; 9643 break; 9644 case 0x0f: 9645 goto op_semantics_74; 9646 break; 9647 } 9648 break; 9649 case 0xf7: 9650 GETBYTE (); 9651 switch (op[2] & 0x0f) 9652 { 9653 case 0x00: 9654 case 0x01: 9655 case 0x02: 9656 case 0x03: 9657 case 0x04: 9658 case 0x05: 9659 case 0x06: 9660 case 0x07: 9661 case 0x08: 9662 case 0x09: 9663 case 0x0a: 9664 case 0x0b: 9665 case 0x0c: 9666 case 0x0d: 9667 case 0x0e: 9668 goto op_semantics_73; 9669 break; 9670 case 0x0f: 9671 goto op_semantics_74; 9672 break; 9673 } 9674 break; 9675 case 0xf8: 9676 GETBYTE (); 9677 switch (op[2] & 0x0f) 9678 { 9679 case 0x00: 9680 case 0x01: 9681 case 0x02: 9682 case 0x03: 9683 case 0x04: 9684 case 0x05: 9685 case 0x06: 9686 case 0x07: 9687 case 0x08: 9688 case 0x09: 9689 case 0x0a: 9690 case 0x0b: 9691 case 0x0c: 9692 case 0x0d: 9693 case 0x0e: 9694 goto op_semantics_73; 9695 break; 9696 case 0x0f: 9697 goto op_semantics_74; 9698 break; 9699 } 9700 break; 9701 case 0xf9: 9702 GETBYTE (); 9703 switch (op[2] & 0x0f) 9704 { 9705 case 0x00: 9706 case 0x01: 9707 case 0x02: 9708 case 0x03: 9709 case 0x04: 9710 case 0x05: 9711 case 0x06: 9712 case 0x07: 9713 case 0x08: 9714 case 0x09: 9715 case 0x0a: 9716 case 0x0b: 9717 case 0x0c: 9718 case 0x0d: 9719 case 0x0e: 9720 goto op_semantics_73; 9721 break; 9722 case 0x0f: 9723 goto op_semantics_74; 9724 break; 9725 } 9726 break; 9727 case 0xfa: 9728 GETBYTE (); 9729 switch (op[2] & 0x0f) 9730 { 9731 case 0x00: 9732 case 0x01: 9733 case 0x02: 9734 case 0x03: 9735 case 0x04: 9736 case 0x05: 9737 case 0x06: 9738 case 0x07: 9739 case 0x08: 9740 case 0x09: 9741 case 0x0a: 9742 case 0x0b: 9743 case 0x0c: 9744 case 0x0d: 9745 case 0x0e: 9746 goto op_semantics_73; 9747 break; 9748 case 0x0f: 9749 goto op_semantics_74; 9750 break; 9751 } 9752 break; 9753 case 0xfb: 9754 GETBYTE (); 9755 switch (op[2] & 0x0f) 9756 { 9757 case 0x00: 9758 case 0x01: 9759 case 0x02: 9760 case 0x03: 9761 case 0x04: 9762 case 0x05: 9763 case 0x06: 9764 case 0x07: 9765 case 0x08: 9766 case 0x09: 9767 case 0x0a: 9768 case 0x0b: 9769 case 0x0c: 9770 case 0x0d: 9771 case 0x0e: 9772 goto op_semantics_73; 9773 break; 9774 case 0x0f: 9775 goto op_semantics_74; 9776 break; 9777 } 9778 break; 9779 case 0xfc: 9780 GETBYTE (); 9781 switch (op[2] & 0x0f) 9782 { 9783 case 0x00: 9784 case 0x01: 9785 case 0x02: 9786 case 0x03: 9787 case 0x04: 9788 case 0x05: 9789 case 0x06: 9790 case 0x07: 9791 case 0x08: 9792 case 0x09: 9793 case 0x0a: 9794 case 0x0b: 9795 case 0x0c: 9796 case 0x0d: 9797 case 0x0e: 9798 goto op_semantics_73; 9799 break; 9800 case 0x0f: 9801 goto op_semantics_74; 9802 break; 9803 } 9804 break; 9805 case 0xfd: 9806 GETBYTE (); 9807 switch (op[2] & 0x0f) 9808 { 9809 case 0x00: 9810 case 0x01: 9811 case 0x02: 9812 case 0x03: 9813 case 0x04: 9814 case 0x05: 9815 case 0x06: 9816 case 0x07: 9817 case 0x08: 9818 case 0x09: 9819 case 0x0a: 9820 case 0x0b: 9821 case 0x0c: 9822 case 0x0d: 9823 case 0x0e: 9824 goto op_semantics_73; 9825 break; 9826 case 0x0f: 9827 goto op_semantics_74; 9828 break; 9829 } 9830 break; 9831 case 0xfe: 9832 GETBYTE (); 9833 switch (op[2] & 0x0f) 9834 { 9835 case 0x00: 9836 case 0x01: 9837 case 0x02: 9838 case 0x03: 9839 case 0x04: 9840 case 0x05: 9841 case 0x06: 9842 case 0x07: 9843 case 0x08: 9844 case 0x09: 9845 case 0x0a: 9846 case 0x0b: 9847 case 0x0c: 9848 case 0x0d: 9849 case 0x0e: 9850 goto op_semantics_73; 9851 break; 9852 case 0x0f: 9853 goto op_semantics_74; 9854 break; 9855 } 9856 break; 9857 case 0xff: 9858 GETBYTE (); 9859 switch (op[2] & 0x0f) 9860 { 9861 case 0x00: 9862 case 0x01: 9863 case 0x02: 9864 case 0x03: 9865 case 0x04: 9866 case 0x05: 9867 case 0x06: 9868 case 0x07: 9869 case 0x08: 9870 case 0x09: 9871 case 0x0a: 9872 case 0x0b: 9873 case 0x0c: 9874 case 0x0d: 9875 case 0x0e: 9876 goto op_semantics_73; 9877 break; 9878 case 0x0f: 9879 goto op_semantics_74; 9880 break; 9881 } 9882 break; 9883 default: UNSUPPORTED(); break; 9884 } 9885 break; 9886 case 0xfd: 9887 GETBYTE (); 9888 switch (op[1] & 0xff) 9889 { 9890 case 0x00: 9891 GETBYTE (); 9892 switch (op[2] & 0x00) 9893 { 9894 case 0x00: 9895 op_semantics_75: 9896 { 9897 /** 1111 1101 0000 a000 srca srcb mulhi %1, %2, %0 */ 9898 #line 848 "rx-decode.opc" 9899 int a AU = (op[1] >> 3) & 0x01; 9900 #line 848 "rx-decode.opc" 9901 int srca AU = (op[2] >> 4) & 0x0f; 9902 #line 848 "rx-decode.opc" 9903 int srcb AU = op[2] & 0x0f; 9904 if (trace) 9905 { 9906 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9907 "/** 1111 1101 0000 a000 srca srcb mulhi %1, %2, %0 */", 9908 op[0], op[1], op[2]); 9909 printf (" a = 0x%x,", a); 9910 printf (" srca = 0x%x,", srca); 9911 printf (" srcb = 0x%x\n", srcb); 9912 } 9913 SYNTAX("mulhi %1, %2, %0"); 9914 #line 848 "rx-decode.opc" 9915 ID(mulhi); DR(a+32); SR(srca); S2R(srcb); F_____; 9916 9917 } 9918 break; 9919 } 9920 break; 9921 case 0x01: 9922 GETBYTE (); 9923 switch (op[2] & 0x00) 9924 { 9925 case 0x00: 9926 op_semantics_76: 9927 { 9928 /** 1111 1101 0000 a001 srca srcb mullo %1, %2, %0 */ 9929 #line 851 "rx-decode.opc" 9930 int a AU = (op[1] >> 3) & 0x01; 9931 #line 851 "rx-decode.opc" 9932 int srca AU = (op[2] >> 4) & 0x0f; 9933 #line 851 "rx-decode.opc" 9934 int srcb AU = op[2] & 0x0f; 9935 if (trace) 9936 { 9937 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9938 "/** 1111 1101 0000 a001 srca srcb mullo %1, %2, %0 */", 9939 op[0], op[1], op[2]); 9940 printf (" a = 0x%x,", a); 9941 printf (" srca = 0x%x,", srca); 9942 printf (" srcb = 0x%x\n", srcb); 9943 } 9944 SYNTAX("mullo %1, %2, %0"); 9945 #line 851 "rx-decode.opc" 9946 ID(mullo); DR(a+32); SR(srca); S2R(srcb); F_____; 9947 9948 } 9949 break; 9950 } 9951 break; 9952 case 0x02: 9953 GETBYTE (); 9954 switch (op[2] & 0x00) 9955 { 9956 case 0x00: 9957 op_semantics_77: 9958 { 9959 /** 1111 1101 0000 a010 srca srcb mullh %1, %2, %0 */ 9960 #line 1079 "rx-decode.opc" 9961 int a AU = (op[1] >> 3) & 0x01; 9962 #line 1079 "rx-decode.opc" 9963 int srca AU = (op[2] >> 4) & 0x0f; 9964 #line 1079 "rx-decode.opc" 9965 int srcb AU = op[2] & 0x0f; 9966 if (trace) 9967 { 9968 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9969 "/** 1111 1101 0000 a010 srca srcb mullh %1, %2, %0 */", 9970 op[0], op[1], op[2]); 9971 printf (" a = 0x%x,", a); 9972 printf (" srca = 0x%x,", srca); 9973 printf (" srcb = 0x%x\n", srcb); 9974 } 9975 SYNTAX("mullh %1, %2, %0"); 9976 #line 1079 "rx-decode.opc" 9977 ID(mullh); DR(a+32); SR(srca); S2R(srcb); F_____; 9978 9979 } 9980 break; 9981 } 9982 break; 9983 case 0x03: 9984 GETBYTE (); 9985 switch (op[2] & 0x00) 9986 { 9987 case 0x00: 9988 op_semantics_78: 9989 { 9990 /** 1111 1101 0000 a011 srca srcb emula %1, %2, %0 */ 9991 #line 1064 "rx-decode.opc" 9992 int a AU = (op[1] >> 3) & 0x01; 9993 #line 1064 "rx-decode.opc" 9994 int srca AU = (op[2] >> 4) & 0x0f; 9995 #line 1064 "rx-decode.opc" 9996 int srcb AU = op[2] & 0x0f; 9997 if (trace) 9998 { 9999 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10000 "/** 1111 1101 0000 a011 srca srcb emula %1, %2, %0 */", 10001 op[0], op[1], op[2]); 10002 printf (" a = 0x%x,", a); 10003 printf (" srca = 0x%x,", srca); 10004 printf (" srcb = 0x%x\n", srcb); 10005 } 10006 SYNTAX("emula %1, %2, %0"); 10007 #line 1064 "rx-decode.opc" 10008 ID(emula); DR(a+32); SR(srca); S2R(srcb); F_____; 10009 10010 } 10011 break; 10012 } 10013 break; 10014 case 0x04: 10015 GETBYTE (); 10016 switch (op[2] & 0x00) 10017 { 10018 case 0x00: 10019 op_semantics_79: 10020 { 10021 /** 1111 1101 0000 a100 srca srcb machi %1, %2, %0 */ 10022 #line 854 "rx-decode.opc" 10023 int a AU = (op[1] >> 3) & 0x01; 10024 #line 854 "rx-decode.opc" 10025 int srca AU = (op[2] >> 4) & 0x0f; 10026 #line 854 "rx-decode.opc" 10027 int srcb AU = op[2] & 0x0f; 10028 if (trace) 10029 { 10030 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10031 "/** 1111 1101 0000 a100 srca srcb machi %1, %2, %0 */", 10032 op[0], op[1], op[2]); 10033 printf (" a = 0x%x,", a); 10034 printf (" srca = 0x%x,", srca); 10035 printf (" srcb = 0x%x\n", srcb); 10036 } 10037 SYNTAX("machi %1, %2, %0"); 10038 #line 854 "rx-decode.opc" 10039 ID(machi); DR(a+32); SR(srca); S2R(srcb); F_____; 10040 10041 } 10042 break; 10043 } 10044 break; 10045 case 0x05: 10046 GETBYTE (); 10047 switch (op[2] & 0x00) 10048 { 10049 case 0x00: 10050 op_semantics_80: 10051 { 10052 /** 1111 1101 0000 a101 srca srcb maclo %1, %2, %0 */ 10053 #line 857 "rx-decode.opc" 10054 int a AU = (op[1] >> 3) & 0x01; 10055 #line 857 "rx-decode.opc" 10056 int srca AU = (op[2] >> 4) & 0x0f; 10057 #line 857 "rx-decode.opc" 10058 int srcb AU = op[2] & 0x0f; 10059 if (trace) 10060 { 10061 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10062 "/** 1111 1101 0000 a101 srca srcb maclo %1, %2, %0 */", 10063 op[0], op[1], op[2]); 10064 printf (" a = 0x%x,", a); 10065 printf (" srca = 0x%x,", srca); 10066 printf (" srcb = 0x%x\n", srcb); 10067 } 10068 SYNTAX("maclo %1, %2, %0"); 10069 #line 857 "rx-decode.opc" 10070 ID(maclo); DR(a+32); SR(srca); S2R(srcb); F_____; 10071 10072 } 10073 break; 10074 } 10075 break; 10076 case 0x06: 10077 GETBYTE (); 10078 switch (op[2] & 0x00) 10079 { 10080 case 0x00: 10081 op_semantics_81: 10082 { 10083 /** 1111 1101 0000 a110 srca srcb maclh %1, %2, %0 */ 10084 #line 1067 "rx-decode.opc" 10085 int a AU = (op[1] >> 3) & 0x01; 10086 #line 1067 "rx-decode.opc" 10087 int srca AU = (op[2] >> 4) & 0x0f; 10088 #line 1067 "rx-decode.opc" 10089 int srcb AU = op[2] & 0x0f; 10090 if (trace) 10091 { 10092 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10093 "/** 1111 1101 0000 a110 srca srcb maclh %1, %2, %0 */", 10094 op[0], op[1], op[2]); 10095 printf (" a = 0x%x,", a); 10096 printf (" srca = 0x%x,", srca); 10097 printf (" srcb = 0x%x\n", srcb); 10098 } 10099 SYNTAX("maclh %1, %2, %0"); 10100 #line 1067 "rx-decode.opc" 10101 ID(maclh); DR(a+32); SR(srca); S2R(srcb); F_____; 10102 10103 } 10104 break; 10105 } 10106 break; 10107 case 0x07: 10108 GETBYTE (); 10109 switch (op[2] & 0x00) 10110 { 10111 case 0x00: 10112 op_semantics_82: 10113 { 10114 /** 1111 1101 0000 a111 srca srcb emaca %1, %2, %0 */ 10115 #line 1058 "rx-decode.opc" 10116 int a AU = (op[1] >> 3) & 0x01; 10117 #line 1058 "rx-decode.opc" 10118 int srca AU = (op[2] >> 4) & 0x0f; 10119 #line 1058 "rx-decode.opc" 10120 int srcb AU = op[2] & 0x0f; 10121 if (trace) 10122 { 10123 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10124 "/** 1111 1101 0000 a111 srca srcb emaca %1, %2, %0 */", 10125 op[0], op[1], op[2]); 10126 printf (" a = 0x%x,", a); 10127 printf (" srca = 0x%x,", srca); 10128 printf (" srcb = 0x%x\n", srcb); 10129 } 10130 SYNTAX("emaca %1, %2, %0"); 10131 #line 1058 "rx-decode.opc" 10132 ID(emaca); DR(a+32); SR(srca); S2R(srcb); F_____; 10133 10134 } 10135 break; 10136 } 10137 break; 10138 case 0x08: 10139 GETBYTE (); 10140 switch (op[2] & 0x00) 10141 { 10142 case 0x00: 10143 goto op_semantics_75; 10144 break; 10145 } 10146 break; 10147 case 0x09: 10148 GETBYTE (); 10149 switch (op[2] & 0x00) 10150 { 10151 case 0x00: 10152 goto op_semantics_76; 10153 break; 10154 } 10155 break; 10156 case 0x0a: 10157 GETBYTE (); 10158 switch (op[2] & 0x00) 10159 { 10160 case 0x00: 10161 goto op_semantics_77; 10162 break; 10163 } 10164 break; 10165 case 0x0b: 10166 GETBYTE (); 10167 switch (op[2] & 0x00) 10168 { 10169 case 0x00: 10170 goto op_semantics_78; 10171 break; 10172 } 10173 break; 10174 case 0x0c: 10175 GETBYTE (); 10176 switch (op[2] & 0x00) 10177 { 10178 case 0x00: 10179 goto op_semantics_79; 10180 break; 10181 } 10182 break; 10183 case 0x0d: 10184 GETBYTE (); 10185 switch (op[2] & 0x00) 10186 { 10187 case 0x00: 10188 goto op_semantics_80; 10189 break; 10190 } 10191 break; 10192 case 0x0e: 10193 GETBYTE (); 10194 switch (op[2] & 0x00) 10195 { 10196 case 0x00: 10197 goto op_semantics_81; 10198 break; 10199 } 10200 break; 10201 case 0x0f: 10202 GETBYTE (); 10203 switch (op[2] & 0x00) 10204 { 10205 case 0x00: 10206 goto op_semantics_82; 10207 break; 10208 } 10209 break; 10210 case 0x17: 10211 GETBYTE (); 10212 switch (op[2] & 0x70) 10213 { 10214 case 0x00: 10215 { 10216 /** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */ 10217 #line 860 "rx-decode.opc" 10218 int a AU = (op[2] >> 7) & 0x01; 10219 #line 860 "rx-decode.opc" 10220 int rsrc AU = op[2] & 0x0f; 10221 if (trace) 10222 { 10223 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10224 "/** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */", 10225 op[0], op[1], op[2]); 10226 printf (" a = 0x%x,", a); 10227 printf (" rsrc = 0x%x\n", rsrc); 10228 } 10229 SYNTAX("mvtachi %1, %0"); 10230 #line 860 "rx-decode.opc" 10231 ID(mvtachi); DR(a+32); SR(rsrc); F_____; 10232 10233 } 10234 break; 10235 case 0x10: 10236 { 10237 /** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */ 10238 #line 863 "rx-decode.opc" 10239 int a AU = (op[2] >> 7) & 0x01; 10240 #line 863 "rx-decode.opc" 10241 int rsrc AU = op[2] & 0x0f; 10242 if (trace) 10243 { 10244 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10245 "/** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */", 10246 op[0], op[1], op[2]); 10247 printf (" a = 0x%x,", a); 10248 printf (" rsrc = 0x%x\n", rsrc); 10249 } 10250 SYNTAX("mvtaclo %1, %0"); 10251 #line 863 "rx-decode.opc" 10252 ID(mvtaclo); DR(a+32); SR(rsrc); F_____; 10253 10254 } 10255 break; 10256 case 0x30: 10257 { 10258 /** 1111 1101 0001 0111 a011 rdst mvtacgu %0, %1 */ 10259 #line 1085 "rx-decode.opc" 10260 int a AU = (op[2] >> 7) & 0x01; 10261 #line 1085 "rx-decode.opc" 10262 int rdst AU = op[2] & 0x0f; 10263 if (trace) 10264 { 10265 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10266 "/** 1111 1101 0001 0111 a011 rdst mvtacgu %0, %1 */", 10267 op[0], op[1], op[2]); 10268 printf (" a = 0x%x,", a); 10269 printf (" rdst = 0x%x\n", rdst); 10270 } 10271 SYNTAX("mvtacgu %0, %1"); 10272 #line 1085 "rx-decode.opc" 10273 ID(mvtacgu); DR(a+32); SR(rdst); F_____; 10274 10275 } 10276 break; 10277 default: UNSUPPORTED(); break; 10278 } 10279 break; 10280 case 0x18: 10281 GETBYTE (); 10282 switch (op[2] & 0x6f) 10283 { 10284 case 0x00: 10285 { 10286 /** 1111 1101 0001 1000 a00i 0000 racw #%1, %0 */ 10287 #line 875 "rx-decode.opc" 10288 int a AU = (op[2] >> 7) & 0x01; 10289 #line 875 "rx-decode.opc" 10290 int i AU = (op[2] >> 4) & 0x01; 10291 if (trace) 10292 { 10293 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10294 "/** 1111 1101 0001 1000 a00i 0000 racw #%1, %0 */", 10295 op[0], op[1], op[2]); 10296 printf (" a = 0x%x,", a); 10297 printf (" i = 0x%x\n", i); 10298 } 10299 SYNTAX("racw #%1, %0"); 10300 #line 875 "rx-decode.opc" 10301 ID(racw); SC(i+1); DR(a+32); F_____; 10302 10303 /*----------------------------------------------------------------------*/ 10304 /* SAT */ 10305 10306 } 10307 break; 10308 case 0x40: 10309 { 10310 /** 1111 1101 0001 1000 a10i 0000 rdacw #%1, %0 */ 10311 #line 1094 "rx-decode.opc" 10312 int a AU = (op[2] >> 7) & 0x01; 10313 #line 1094 "rx-decode.opc" 10314 int i AU = (op[2] >> 4) & 0x01; 10315 if (trace) 10316 { 10317 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10318 "/** 1111 1101 0001 1000 a10i 0000 rdacw #%1, %0 */", 10319 op[0], op[1], op[2]); 10320 printf (" a = 0x%x,", a); 10321 printf (" i = 0x%x\n", i); 10322 } 10323 SYNTAX("rdacw #%1, %0"); 10324 #line 1094 "rx-decode.opc" 10325 ID(rdacw); SC(i+1); DR(a+32); F_____; 10326 10327 } 10328 break; 10329 default: UNSUPPORTED(); break; 10330 } 10331 break; 10332 case 0x19: 10333 GETBYTE (); 10334 switch (op[2] & 0x6f) 10335 { 10336 case 0x00: 10337 { 10338 /** 1111 1101 0001 1001 a00i 0000 racl #%1, %0 */ 10339 #line 1088 "rx-decode.opc" 10340 int a AU = (op[2] >> 7) & 0x01; 10341 #line 1088 "rx-decode.opc" 10342 int i AU = (op[2] >> 4) & 0x01; 10343 if (trace) 10344 { 10345 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10346 "/** 1111 1101 0001 1001 a00i 0000 racl #%1, %0 */", 10347 op[0], op[1], op[2]); 10348 printf (" a = 0x%x,", a); 10349 printf (" i = 0x%x\n", i); 10350 } 10351 SYNTAX("racl #%1, %0"); 10352 #line 1088 "rx-decode.opc" 10353 ID(racl); SC(i+1); DR(a+32); F_____; 10354 10355 } 10356 break; 10357 case 0x40: 10358 { 10359 /** 1111 1101 0001 1001 a10i 0000 rdacl #%1, %0 */ 10360 #line 1091 "rx-decode.opc" 10361 int a AU = (op[2] >> 7) & 0x01; 10362 #line 1091 "rx-decode.opc" 10363 int i AU = (op[2] >> 4) & 0x01; 10364 if (trace) 10365 { 10366 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10367 "/** 1111 1101 0001 1001 a10i 0000 rdacl #%1, %0 */", 10368 op[0], op[1], op[2]); 10369 printf (" a = 0x%x,", a); 10370 printf (" i = 0x%x\n", i); 10371 } 10372 SYNTAX("rdacl #%1, %0"); 10373 #line 1091 "rx-decode.opc" 10374 ID(rdacl); SC(i+1); DR(a+32); F_____; 10375 10376 } 10377 break; 10378 default: UNSUPPORTED(); break; 10379 } 10380 break; 10381 case 0x1e: 10382 GETBYTE (); 10383 switch (op[2] & 0x30) 10384 { 10385 case 0x00: 10386 op_semantics_83: 10387 { 10388 /** 1111 1101 0001 111i a m00 rdst mvfachi #%2, %1, %0 */ 10389 #line 866 "rx-decode.opc" 10390 int i AU = op[1] & 0x01; 10391 #line 866 "rx-decode.opc" 10392 int a AU = (op[2] >> 7) & 0x01; 10393 #line 866 "rx-decode.opc" 10394 int m AU = (op[2] >> 6) & 0x01; 10395 #line 866 "rx-decode.opc" 10396 int rdst AU = op[2] & 0x0f; 10397 if (trace) 10398 { 10399 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10400 "/** 1111 1101 0001 111i a m00 rdst mvfachi #%2, %1, %0 */", 10401 op[0], op[1], op[2]); 10402 printf (" i = 0x%x,", i); 10403 printf (" a = 0x%x,", a); 10404 printf (" m = 0x%x,", m); 10405 printf (" rdst = 0x%x\n", rdst); 10406 } 10407 SYNTAX("mvfachi #%2, %1, %0"); 10408 #line 866 "rx-decode.opc" 10409 ID(mvfachi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____; 10410 10411 } 10412 break; 10413 case 0x10: 10414 op_semantics_84: 10415 { 10416 /** 1111 1101 0001 111i a m01 rdst mvfaclo #%2, %1, %0 */ 10417 #line 872 "rx-decode.opc" 10418 int i AU = op[1] & 0x01; 10419 #line 872 "rx-decode.opc" 10420 int a AU = (op[2] >> 7) & 0x01; 10421 #line 872 "rx-decode.opc" 10422 int m AU = (op[2] >> 6) & 0x01; 10423 #line 872 "rx-decode.opc" 10424 int rdst AU = op[2] & 0x0f; 10425 if (trace) 10426 { 10427 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10428 "/** 1111 1101 0001 111i a m01 rdst mvfaclo #%2, %1, %0 */", 10429 op[0], op[1], op[2]); 10430 printf (" i = 0x%x,", i); 10431 printf (" a = 0x%x,", a); 10432 printf (" m = 0x%x,", m); 10433 printf (" rdst = 0x%x\n", rdst); 10434 } 10435 SYNTAX("mvfaclo #%2, %1, %0"); 10436 #line 872 "rx-decode.opc" 10437 ID(mvfaclo); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____; 10438 10439 } 10440 break; 10441 case 0x20: 10442 op_semantics_85: 10443 { 10444 /** 1111 1101 0001 111i a m10 rdst mvfacmi #%2, %1, %0 */ 10445 #line 869 "rx-decode.opc" 10446 int i AU = op[1] & 0x01; 10447 #line 869 "rx-decode.opc" 10448 int a AU = (op[2] >> 7) & 0x01; 10449 #line 869 "rx-decode.opc" 10450 int m AU = (op[2] >> 6) & 0x01; 10451 #line 869 "rx-decode.opc" 10452 int rdst AU = op[2] & 0x0f; 10453 if (trace) 10454 { 10455 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10456 "/** 1111 1101 0001 111i a m10 rdst mvfacmi #%2, %1, %0 */", 10457 op[0], op[1], op[2]); 10458 printf (" i = 0x%x,", i); 10459 printf (" a = 0x%x,", a); 10460 printf (" m = 0x%x,", m); 10461 printf (" rdst = 0x%x\n", rdst); 10462 } 10463 SYNTAX("mvfacmi #%2, %1, %0"); 10464 #line 869 "rx-decode.opc" 10465 ID(mvfacmi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____; 10466 10467 } 10468 break; 10469 case 0x30: 10470 op_semantics_86: 10471 { 10472 /** 1111 1101 0001 111i a m11 rdst mvfacgu #%2, %1, %0 */ 10473 #line 1082 "rx-decode.opc" 10474 int i AU = op[1] & 0x01; 10475 #line 1082 "rx-decode.opc" 10476 int a AU = (op[2] >> 7) & 0x01; 10477 #line 1082 "rx-decode.opc" 10478 int m AU = (op[2] >> 6) & 0x01; 10479 #line 1082 "rx-decode.opc" 10480 int rdst AU = op[2] & 0x0f; 10481 if (trace) 10482 { 10483 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10484 "/** 1111 1101 0001 111i a m11 rdst mvfacgu #%2, %1, %0 */", 10485 op[0], op[1], op[2]); 10486 printf (" i = 0x%x,", i); 10487 printf (" a = 0x%x,", a); 10488 printf (" m = 0x%x,", m); 10489 printf (" rdst = 0x%x\n", rdst); 10490 } 10491 SYNTAX("mvfacgu #%2, %1, %0"); 10492 #line 1082 "rx-decode.opc" 10493 ID(mvfacgu); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____; 10494 10495 } 10496 break; 10497 } 10498 break; 10499 case 0x1f: 10500 GETBYTE (); 10501 switch (op[2] & 0x30) 10502 { 10503 case 0x00: 10504 goto op_semantics_83; 10505 break; 10506 case 0x10: 10507 goto op_semantics_84; 10508 break; 10509 case 0x20: 10510 goto op_semantics_85; 10511 break; 10512 case 0x30: 10513 goto op_semantics_86; 10514 break; 10515 } 10516 break; 10517 case 0x20: 10518 GETBYTE (); 10519 switch (op[2] & 0x00) 10520 { 10521 case 0x00: 10522 op_semantics_87: 10523 { 10524 /** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */ 10525 #line 344 "rx-decode.opc" 10526 int p AU = (op[1] >> 2) & 0x01; 10527 #line 344 "rx-decode.opc" 10528 int sz AU = op[1] & 0x03; 10529 #line 344 "rx-decode.opc" 10530 int rdst AU = (op[2] >> 4) & 0x0f; 10531 #line 344 "rx-decode.opc" 10532 int rsrc AU = op[2] & 0x0f; 10533 if (trace) 10534 { 10535 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10536 "/** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */", 10537 op[0], op[1], op[2]); 10538 printf (" p = 0x%x,", p); 10539 printf (" sz = 0x%x,", sz); 10540 printf (" rdst = 0x%x,", rdst); 10541 printf (" rsrc = 0x%x\n", rsrc); 10542 } 10543 SYNTAX("mov%s %1, %0"); 10544 #line 344 "rx-decode.opc" 10545 ID(mov); sBWL (sz); SR(rsrc); F_____; 10546 OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0); 10547 10548 } 10549 break; 10550 } 10551 break; 10552 case 0x21: 10553 GETBYTE (); 10554 switch (op[2] & 0x00) 10555 { 10556 case 0x00: 10557 goto op_semantics_87; 10558 break; 10559 } 10560 break; 10561 case 0x22: 10562 GETBYTE (); 10563 switch (op[2] & 0x00) 10564 { 10565 case 0x00: 10566 goto op_semantics_87; 10567 break; 10568 } 10569 break; 10570 case 0x24: 10571 GETBYTE (); 10572 switch (op[2] & 0x00) 10573 { 10574 case 0x00: 10575 goto op_semantics_87; 10576 break; 10577 } 10578 break; 10579 case 0x25: 10580 GETBYTE (); 10581 switch (op[2] & 0x00) 10582 { 10583 case 0x00: 10584 goto op_semantics_87; 10585 break; 10586 } 10587 break; 10588 case 0x26: 10589 GETBYTE (); 10590 switch (op[2] & 0x00) 10591 { 10592 case 0x00: 10593 goto op_semantics_87; 10594 break; 10595 } 10596 break; 10597 case 0x27: 10598 GETBYTE (); 10599 switch (op[2] & 0x00) 10600 { 10601 case 0x00: 10602 { 10603 /** 1111 1101 0010 0111 rdst rsrc movco %1, [%0] */ 10604 #line 1046 "rx-decode.opc" 10605 int rdst AU = (op[2] >> 4) & 0x0f; 10606 #line 1046 "rx-decode.opc" 10607 int rsrc AU = op[2] & 0x0f; 10608 if (trace) 10609 { 10610 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10611 "/** 1111 1101 0010 0111 rdst rsrc movco %1, [%0] */", 10612 op[0], op[1], op[2]); 10613 printf (" rdst = 0x%x,", rdst); 10614 printf (" rsrc = 0x%x\n", rsrc); 10615 } 10616 SYNTAX("movco %1, [%0]"); 10617 #line 1046 "rx-decode.opc" 10618 ID(movco); SR(rsrc); DR(rdst); F_____; 10619 10620 } 10621 break; 10622 } 10623 break; 10624 case 0x28: 10625 GETBYTE (); 10626 switch (op[2] & 0x00) 10627 { 10628 case 0x00: 10629 op_semantics_88: 10630 { 10631 /** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */ 10632 #line 348 "rx-decode.opc" 10633 int p AU = (op[1] >> 2) & 0x01; 10634 #line 348 "rx-decode.opc" 10635 int sz AU = op[1] & 0x03; 10636 #line 348 "rx-decode.opc" 10637 int rsrc AU = (op[2] >> 4) & 0x0f; 10638 #line 348 "rx-decode.opc" 10639 int rdst AU = op[2] & 0x0f; 10640 if (trace) 10641 { 10642 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10643 "/** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */", 10644 op[0], op[1], op[2]); 10645 printf (" p = 0x%x,", p); 10646 printf (" sz = 0x%x,", sz); 10647 printf (" rsrc = 0x%x,", rsrc); 10648 printf (" rdst = 0x%x\n", rdst); 10649 } 10650 SYNTAX("mov%s %1, %0"); 10651 #line 348 "rx-decode.opc" 10652 ID(mov); sBWL (sz); DR(rdst); F_____; 10653 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0); 10654 10655 } 10656 break; 10657 } 10658 break; 10659 case 0x29: 10660 GETBYTE (); 10661 switch (op[2] & 0x00) 10662 { 10663 case 0x00: 10664 goto op_semantics_88; 10665 break; 10666 } 10667 break; 10668 case 0x2a: 10669 GETBYTE (); 10670 switch (op[2] & 0x00) 10671 { 10672 case 0x00: 10673 goto op_semantics_88; 10674 break; 10675 } 10676 break; 10677 case 0x2c: 10678 GETBYTE (); 10679 switch (op[2] & 0x00) 10680 { 10681 case 0x00: 10682 goto op_semantics_88; 10683 break; 10684 } 10685 break; 10686 case 0x2d: 10687 GETBYTE (); 10688 switch (op[2] & 0x00) 10689 { 10690 case 0x00: 10691 goto op_semantics_88; 10692 break; 10693 } 10694 break; 10695 case 0x2e: 10696 GETBYTE (); 10697 switch (op[2] & 0x00) 10698 { 10699 case 0x00: 10700 goto op_semantics_88; 10701 break; 10702 } 10703 break; 10704 case 0x2f: 10705 GETBYTE (); 10706 switch (op[2] & 0x00) 10707 { 10708 case 0x00: 10709 { 10710 /** 1111 1101 0010 1111 rsrc rdst movli [%1], %0 */ 10711 #line 1049 "rx-decode.opc" 10712 int rsrc AU = (op[2] >> 4) & 0x0f; 10713 #line 1049 "rx-decode.opc" 10714 int rdst AU = op[2] & 0x0f; 10715 if (trace) 10716 { 10717 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10718 "/** 1111 1101 0010 1111 rsrc rdst movli [%1], %0 */", 10719 op[0], op[1], op[2]); 10720 printf (" rsrc = 0x%x,", rsrc); 10721 printf (" rdst = 0x%x\n", rdst); 10722 } 10723 SYNTAX("movli [%1], %0"); 10724 #line 1049 "rx-decode.opc" 10725 ID(movli); SR(rsrc); DR(rdst); F_____; 10726 10727 } 10728 break; 10729 } 10730 break; 10731 case 0x38: 10732 GETBYTE (); 10733 switch (op[2] & 0x00) 10734 { 10735 case 0x00: 10736 op_semantics_89: 10737 { 10738 /** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */ 10739 #line 358 "rx-decode.opc" 10740 int p AU = (op[1] >> 2) & 0x01; 10741 #line 358 "rx-decode.opc" 10742 int sz AU = op[1] & 0x03; 10743 #line 358 "rx-decode.opc" 10744 int rsrc AU = (op[2] >> 4) & 0x0f; 10745 #line 358 "rx-decode.opc" 10746 int rdst AU = op[2] & 0x0f; 10747 if (trace) 10748 { 10749 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10750 "/** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */", 10751 op[0], op[1], op[2]); 10752 printf (" p = 0x%x,", p); 10753 printf (" sz = 0x%x,", sz); 10754 printf (" rsrc = 0x%x,", rsrc); 10755 printf (" rdst = 0x%x\n", rdst); 10756 } 10757 SYNTAX("movu%s %1, %0"); 10758 #line 358 "rx-decode.opc" 10759 ID(mov); uBW (sz); DR(rdst); F_____; 10760 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0); 10761 10762 /*----------------------------------------------------------------------*/ 10763 /* PUSH/POP */ 10764 10765 } 10766 break; 10767 } 10768 break; 10769 case 0x39: 10770 GETBYTE (); 10771 switch (op[2] & 0x00) 10772 { 10773 case 0x00: 10774 goto op_semantics_89; 10775 break; 10776 } 10777 break; 10778 case 0x3a: 10779 GETBYTE (); 10780 switch (op[2] & 0x00) 10781 { 10782 case 0x00: 10783 goto op_semantics_89; 10784 break; 10785 } 10786 break; 10787 case 0x3c: 10788 GETBYTE (); 10789 switch (op[2] & 0x00) 10790 { 10791 case 0x00: 10792 goto op_semantics_89; 10793 break; 10794 } 10795 break; 10796 case 0x3d: 10797 GETBYTE (); 10798 switch (op[2] & 0x00) 10799 { 10800 case 0x00: 10801 goto op_semantics_89; 10802 break; 10803 } 10804 break; 10805 case 0x3e: 10806 GETBYTE (); 10807 switch (op[2] & 0x00) 10808 { 10809 case 0x00: 10810 goto op_semantics_89; 10811 break; 10812 } 10813 break; 10814 case 0x44: 10815 GETBYTE (); 10816 switch (op[2] & 0x00) 10817 { 10818 case 0x00: 10819 op_semantics_90: 10820 { 10821 /** 1111 1101 0100 a100 srca srcb msbhi %1, %2, %0 */ 10822 #line 1070 "rx-decode.opc" 10823 int a AU = (op[1] >> 3) & 0x01; 10824 #line 1070 "rx-decode.opc" 10825 int srca AU = (op[2] >> 4) & 0x0f; 10826 #line 1070 "rx-decode.opc" 10827 int srcb AU = op[2] & 0x0f; 10828 if (trace) 10829 { 10830 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10831 "/** 1111 1101 0100 a100 srca srcb msbhi %1, %2, %0 */", 10832 op[0], op[1], op[2]); 10833 printf (" a = 0x%x,", a); 10834 printf (" srca = 0x%x,", srca); 10835 printf (" srcb = 0x%x\n", srcb); 10836 } 10837 SYNTAX("msbhi %1, %2, %0"); 10838 #line 1070 "rx-decode.opc" 10839 ID(msbhi); DR(a+32); SR(srca); S2R(srcb); F_____; 10840 10841 } 10842 break; 10843 } 10844 break; 10845 case 0x45: 10846 GETBYTE (); 10847 switch (op[2] & 0x00) 10848 { 10849 case 0x00: 10850 op_semantics_91: 10851 { 10852 /** 1111 1101 0100 a101 srca srcb msblo %1, %2, %0 */ 10853 #line 1076 "rx-decode.opc" 10854 int a AU = (op[1] >> 3) & 0x01; 10855 #line 1076 "rx-decode.opc" 10856 int srca AU = (op[2] >> 4) & 0x0f; 10857 #line 1076 "rx-decode.opc" 10858 int srcb AU = op[2] & 0x0f; 10859 if (trace) 10860 { 10861 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10862 "/** 1111 1101 0100 a101 srca srcb msblo %1, %2, %0 */", 10863 op[0], op[1], op[2]); 10864 printf (" a = 0x%x,", a); 10865 printf (" srca = 0x%x,", srca); 10866 printf (" srcb = 0x%x\n", srcb); 10867 } 10868 SYNTAX("msblo %1, %2, %0"); 10869 #line 1076 "rx-decode.opc" 10870 ID(msblo); DR(a+32); SR(srca); S2R(srcb); F_____; 10871 10872 } 10873 break; 10874 } 10875 break; 10876 case 0x46: 10877 GETBYTE (); 10878 switch (op[2] & 0x00) 10879 { 10880 case 0x00: 10881 op_semantics_92: 10882 { 10883 /** 1111 1101 0100 a110 srca srcb msblh %1, %2, %0 */ 10884 #line 1073 "rx-decode.opc" 10885 int a AU = (op[1] >> 3) & 0x01; 10886 #line 1073 "rx-decode.opc" 10887 int srca AU = (op[2] >> 4) & 0x0f; 10888 #line 1073 "rx-decode.opc" 10889 int srcb AU = op[2] & 0x0f; 10890 if (trace) 10891 { 10892 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10893 "/** 1111 1101 0100 a110 srca srcb msblh %1, %2, %0 */", 10894 op[0], op[1], op[2]); 10895 printf (" a = 0x%x,", a); 10896 printf (" srca = 0x%x,", srca); 10897 printf (" srcb = 0x%x\n", srcb); 10898 } 10899 SYNTAX("msblh %1, %2, %0"); 10900 #line 1073 "rx-decode.opc" 10901 ID(msblh); DR(a+32); SR(srca); S2R(srcb); F_____; 10902 10903 } 10904 break; 10905 } 10906 break; 10907 case 0x47: 10908 GETBYTE (); 10909 switch (op[2] & 0x00) 10910 { 10911 case 0x00: 10912 op_semantics_93: 10913 { 10914 /** 1111 1101 0100 a111 srca srcb emsba %1, %2, %0 */ 10915 #line 1061 "rx-decode.opc" 10916 int a AU = (op[1] >> 3) & 0x01; 10917 #line 1061 "rx-decode.opc" 10918 int srca AU = (op[2] >> 4) & 0x0f; 10919 #line 1061 "rx-decode.opc" 10920 int srcb AU = op[2] & 0x0f; 10921 if (trace) 10922 { 10923 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10924 "/** 1111 1101 0100 a111 srca srcb emsba %1, %2, %0 */", 10925 op[0], op[1], op[2]); 10926 printf (" a = 0x%x,", a); 10927 printf (" srca = 0x%x,", srca); 10928 printf (" srcb = 0x%x\n", srcb); 10929 } 10930 SYNTAX("emsba %1, %2, %0"); 10931 #line 1061 "rx-decode.opc" 10932 ID(emsba); DR(a+32); SR(srca); S2R(srcb); F_____; 10933 10934 } 10935 break; 10936 } 10937 break; 10938 case 0x4c: 10939 GETBYTE (); 10940 switch (op[2] & 0x00) 10941 { 10942 case 0x00: 10943 goto op_semantics_90; 10944 break; 10945 } 10946 break; 10947 case 0x4d: 10948 GETBYTE (); 10949 switch (op[2] & 0x00) 10950 { 10951 case 0x00: 10952 goto op_semantics_91; 10953 break; 10954 } 10955 break; 10956 case 0x4e: 10957 GETBYTE (); 10958 switch (op[2] & 0x00) 10959 { 10960 case 0x00: 10961 goto op_semantics_92; 10962 break; 10963 } 10964 break; 10965 case 0x4f: 10966 GETBYTE (); 10967 switch (op[2] & 0x00) 10968 { 10969 case 0x00: 10970 goto op_semantics_93; 10971 break; 10972 } 10973 break; 10974 case 0x60: 10975 GETBYTE (); 10976 switch (op[2] & 0x00) 10977 { 10978 case 0x00: 10979 { 10980 /** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */ 10981 #line 729 "rx-decode.opc" 10982 int rsrc AU = (op[2] >> 4) & 0x0f; 10983 #line 729 "rx-decode.opc" 10984 int rdst AU = op[2] & 0x0f; 10985 if (trace) 10986 { 10987 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10988 "/** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */", 10989 op[0], op[1], op[2]); 10990 printf (" rsrc = 0x%x,", rsrc); 10991 printf (" rdst = 0x%x\n", rdst); 10992 } 10993 SYNTAX("shlr %2, %0"); 10994 #line 729 "rx-decode.opc" 10995 ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F__SZC; 10996 10997 } 10998 break; 10999 } 11000 break; 11001 case 0x61: 11002 GETBYTE (); 11003 switch (op[2] & 0x00) 11004 { 11005 case 0x00: 11006 { 11007 /** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */ 11008 #line 719 "rx-decode.opc" 11009 int rsrc AU = (op[2] >> 4) & 0x0f; 11010 #line 719 "rx-decode.opc" 11011 int rdst AU = op[2] & 0x0f; 11012 if (trace) 11013 { 11014 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11015 "/** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */", 11016 op[0], op[1], op[2]); 11017 printf (" rsrc = 0x%x,", rsrc); 11018 printf (" rdst = 0x%x\n", rdst); 11019 } 11020 SYNTAX("shar %2, %0"); 11021 #line 719 "rx-decode.opc" 11022 ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F_0SZC; 11023 11024 } 11025 break; 11026 } 11027 break; 11028 case 0x62: 11029 GETBYTE (); 11030 switch (op[2] & 0x00) 11031 { 11032 case 0x00: 11033 { 11034 /** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */ 11035 #line 709 "rx-decode.opc" 11036 int rsrc AU = (op[2] >> 4) & 0x0f; 11037 #line 709 "rx-decode.opc" 11038 int rdst AU = op[2] & 0x0f; 11039 if (trace) 11040 { 11041 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11042 "/** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */", 11043 op[0], op[1], op[2]); 11044 printf (" rsrc = 0x%x,", rsrc); 11045 printf (" rdst = 0x%x\n", rdst); 11046 } 11047 SYNTAX("shll %2, %0"); 11048 #line 709 "rx-decode.opc" 11049 ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F_OSZC; 11050 11051 } 11052 break; 11053 } 11054 break; 11055 case 0x64: 11056 GETBYTE (); 11057 switch (op[2] & 0x00) 11058 { 11059 case 0x00: 11060 { 11061 /** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */ 11062 #line 753 "rx-decode.opc" 11063 int rsrc AU = (op[2] >> 4) & 0x0f; 11064 #line 753 "rx-decode.opc" 11065 int rdst AU = op[2] & 0x0f; 11066 if (trace) 11067 { 11068 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11069 "/** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */", 11070 op[0], op[1], op[2]); 11071 printf (" rsrc = 0x%x,", rsrc); 11072 printf (" rdst = 0x%x\n", rdst); 11073 } 11074 SYNTAX("rotr %1, %0"); 11075 #line 753 "rx-decode.opc" 11076 ID(rotr); SR(rsrc); DR(rdst); F__SZC; 11077 11078 } 11079 break; 11080 } 11081 break; 11082 case 0x65: 11083 GETBYTE (); 11084 switch (op[2] & 0x00) 11085 { 11086 case 0x00: 11087 { 11088 /** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */ 11089 #line 756 "rx-decode.opc" 11090 int rsrc AU = (op[2] >> 4) & 0x0f; 11091 #line 756 "rx-decode.opc" 11092 int rdst AU = op[2] & 0x0f; 11093 if (trace) 11094 { 11095 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11096 "/** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */", 11097 op[0], op[1], op[2]); 11098 printf (" rsrc = 0x%x,", rsrc); 11099 printf (" rdst = 0x%x\n", rdst); 11100 } 11101 SYNTAX("revw %1, %0"); 11102 #line 756 "rx-decode.opc" 11103 ID(revw); SR(rsrc); DR(rdst); 11104 11105 } 11106 break; 11107 } 11108 break; 11109 case 0x66: 11110 GETBYTE (); 11111 switch (op[2] & 0x00) 11112 { 11113 case 0x00: 11114 { 11115 /** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */ 11116 #line 747 "rx-decode.opc" 11117 int rsrc AU = (op[2] >> 4) & 0x0f; 11118 #line 747 "rx-decode.opc" 11119 int rdst AU = op[2] & 0x0f; 11120 if (trace) 11121 { 11122 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11123 "/** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */", 11124 op[0], op[1], op[2]); 11125 printf (" rsrc = 0x%x,", rsrc); 11126 printf (" rdst = 0x%x\n", rdst); 11127 } 11128 SYNTAX("rotl %1, %0"); 11129 #line 747 "rx-decode.opc" 11130 ID(rotl); SR(rsrc); DR(rdst); F__SZC; 11131 11132 } 11133 break; 11134 } 11135 break; 11136 case 0x67: 11137 GETBYTE (); 11138 switch (op[2] & 0x00) 11139 { 11140 case 0x00: 11141 { 11142 /** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */ 11143 #line 759 "rx-decode.opc" 11144 int rsrc AU = (op[2] >> 4) & 0x0f; 11145 #line 759 "rx-decode.opc" 11146 int rdst AU = op[2] & 0x0f; 11147 if (trace) 11148 { 11149 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11150 "/** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */", 11151 op[0], op[1], op[2]); 11152 printf (" rsrc = 0x%x,", rsrc); 11153 printf (" rdst = 0x%x\n", rdst); 11154 } 11155 SYNTAX("revl %1, %0"); 11156 #line 759 "rx-decode.opc" 11157 ID(revl); SR(rsrc); DR(rdst); 11158 11159 /*----------------------------------------------------------------------*/ 11160 /* BRANCH */ 11161 11162 } 11163 break; 11164 } 11165 break; 11166 case 0x68: 11167 GETBYTE (); 11168 switch (op[2] & 0x00) 11169 { 11170 case 0x00: 11171 op_semantics_94: 11172 { 11173 /** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */ 11174 #line 1010 "rx-decode.opc" 11175 int c AU = op[1] & 0x01; 11176 #line 1010 "rx-decode.opc" 11177 int rsrc AU = (op[2] >> 4) & 0x0f; 11178 #line 1010 "rx-decode.opc" 11179 int rdst AU = op[2] & 0x0f; 11180 if (trace) 11181 { 11182 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11183 "/** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */", 11184 op[0], op[1], op[2]); 11185 printf (" c = 0x%x,", c); 11186 printf (" rsrc = 0x%x,", rsrc); 11187 printf (" rdst = 0x%x\n", rdst); 11188 } 11189 SYNTAX("mvtc %1, %0"); 11190 #line 1010 "rx-decode.opc" 11191 ID(mov); SR(rsrc); DR(c*16+rdst + 16); 11192 11193 } 11194 break; 11195 } 11196 break; 11197 case 0x69: 11198 GETBYTE (); 11199 switch (op[2] & 0x00) 11200 { 11201 case 0x00: 11202 goto op_semantics_94; 11203 break; 11204 } 11205 break; 11206 case 0x6a: 11207 GETBYTE (); 11208 switch (op[2] & 0x00) 11209 { 11210 case 0x00: 11211 op_semantics_95: 11212 { 11213 /** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */ 11214 #line 1013 "rx-decode.opc" 11215 int s AU = op[1] & 0x01; 11216 #line 1013 "rx-decode.opc" 11217 int rsrc AU = (op[2] >> 4) & 0x0f; 11218 #line 1013 "rx-decode.opc" 11219 int rdst AU = op[2] & 0x0f; 11220 if (trace) 11221 { 11222 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11223 "/** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */", 11224 op[0], op[1], op[2]); 11225 printf (" s = 0x%x,", s); 11226 printf (" rsrc = 0x%x,", rsrc); 11227 printf (" rdst = 0x%x\n", rdst); 11228 } 11229 SYNTAX("mvfc %1, %0"); 11230 #line 1013 "rx-decode.opc" 11231 ID(mov); SR((s*16+rsrc) + 16); DR(rdst); 11232 11233 /*----------------------------------------------------------------------*/ 11234 /* INTERRUPTS */ 11235 11236 } 11237 break; 11238 } 11239 break; 11240 case 0x6b: 11241 GETBYTE (); 11242 switch (op[2] & 0x00) 11243 { 11244 case 0x00: 11245 goto op_semantics_95; 11246 break; 11247 } 11248 break; 11249 case 0x6c: 11250 GETBYTE (); 11251 switch (op[2] & 0x00) 11252 { 11253 case 0x00: 11254 op_semantics_96: 11255 { 11256 /** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */ 11257 #line 750 "rx-decode.opc" 11258 int i AU = op[1] & 0x01; 11259 #line 750 "rx-decode.opc" 11260 int mmmm AU = (op[2] >> 4) & 0x0f; 11261 #line 750 "rx-decode.opc" 11262 int rdst AU = op[2] & 0x0f; 11263 if (trace) 11264 { 11265 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11266 "/** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */", 11267 op[0], op[1], op[2]); 11268 printf (" i = 0x%x,", i); 11269 printf (" mmmm = 0x%x,", mmmm); 11270 printf (" rdst = 0x%x\n", rdst); 11271 } 11272 SYNTAX("rotr #%1, %0"); 11273 #line 750 "rx-decode.opc" 11274 ID(rotr); SC(i*16+mmmm); DR(rdst); F__SZC; 11275 11276 } 11277 break; 11278 } 11279 break; 11280 case 0x6d: 11281 GETBYTE (); 11282 switch (op[2] & 0x00) 11283 { 11284 case 0x00: 11285 goto op_semantics_96; 11286 break; 11287 } 11288 break; 11289 case 0x6e: 11290 GETBYTE (); 11291 switch (op[2] & 0x00) 11292 { 11293 case 0x00: 11294 op_semantics_97: 11295 { 11296 /** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */ 11297 #line 744 "rx-decode.opc" 11298 int i AU = op[1] & 0x01; 11299 #line 744 "rx-decode.opc" 11300 int mmmm AU = (op[2] >> 4) & 0x0f; 11301 #line 744 "rx-decode.opc" 11302 int rdst AU = op[2] & 0x0f; 11303 if (trace) 11304 { 11305 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11306 "/** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */", 11307 op[0], op[1], op[2]); 11308 printf (" i = 0x%x,", i); 11309 printf (" mmmm = 0x%x,", mmmm); 11310 printf (" rdst = 0x%x\n", rdst); 11311 } 11312 SYNTAX("rotl #%1, %0"); 11313 #line 744 "rx-decode.opc" 11314 ID(rotl); SC(i*16+mmmm); DR(rdst); F__SZC; 11315 11316 } 11317 break; 11318 } 11319 break; 11320 case 0x6f: 11321 GETBYTE (); 11322 switch (op[2] & 0x00) 11323 { 11324 case 0x00: 11325 goto op_semantics_97; 11326 break; 11327 } 11328 break; 11329 case 0x70: 11330 GETBYTE (); 11331 switch (op[2] & 0xf0) 11332 { 11333 case 0x20: 11334 op_semantics_98: 11335 { 11336 /** 1111 1101 0111 im00 0010rdst adc #%1, %0 */ 11337 #line 488 "rx-decode.opc" 11338 int im AU = (op[1] >> 2) & 0x03; 11339 #line 488 "rx-decode.opc" 11340 int rdst AU = op[2] & 0x0f; 11341 if (trace) 11342 { 11343 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11344 "/** 1111 1101 0111 im00 0010rdst adc #%1, %0 */", 11345 op[0], op[1], op[2]); 11346 printf (" im = 0x%x,", im); 11347 printf (" rdst = 0x%x\n", rdst); 11348 } 11349 SYNTAX("adc #%1, %0"); 11350 #line 488 "rx-decode.opc" 11351 ID(adc); SC(IMMex(im)); DR(rdst); F_OSZC; 11352 11353 } 11354 break; 11355 case 0x40: 11356 op_semantics_99: 11357 { 11358 /** 1111 1101 0111 im00 0100rdst max #%1, %0 */ 11359 #line 570 "rx-decode.opc" 11360 int im AU = (op[1] >> 2) & 0x03; 11361 #line 570 "rx-decode.opc" 11362 int rdst AU = op[2] & 0x0f; 11363 if (trace) 11364 { 11365 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11366 "/** 1111 1101 0111 im00 0100rdst max #%1, %0 */", 11367 op[0], op[1], op[2]); 11368 printf (" im = 0x%x,", im); 11369 printf (" rdst = 0x%x\n", rdst); 11370 } 11371 SYNTAX("max #%1, %0"); 11372 #line 570 "rx-decode.opc" 11373 int val = IMMex (im); 11374 if (im == 0 && (unsigned) val == 0x80000000 && rdst == 0) 11375 { 11376 ID (nop7); 11377 SYNTAX("nop\t; max\t#0x80000000, r0"); 11378 } 11379 else 11380 { 11381 ID(max); 11382 } 11383 DR(rdst); SC(val); 11384 11385 } 11386 break; 11387 case 0x50: 11388 op_semantics_100: 11389 { 11390 /** 1111 1101 0111 im00 0101rdst min #%1, %0 */ 11391 #line 600 "rx-decode.opc" 11392 int im AU = (op[1] >> 2) & 0x03; 11393 #line 600 "rx-decode.opc" 11394 int rdst AU = op[2] & 0x0f; 11395 if (trace) 11396 { 11397 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11398 "/** 1111 1101 0111 im00 0101rdst min #%1, %0 */", 11399 op[0], op[1], op[2]); 11400 printf (" im = 0x%x,", im); 11401 printf (" rdst = 0x%x\n", rdst); 11402 } 11403 SYNTAX("min #%1, %0"); 11404 #line 600 "rx-decode.opc" 11405 ID(min); DR(rdst); SC(IMMex(im)); 11406 11407 } 11408 break; 11409 case 0x60: 11410 op_semantics_101: 11411 { 11412 /** 1111 1101 0111 im00 0110rdst emul #%1, %0 */ 11413 #line 658 "rx-decode.opc" 11414 int im AU = (op[1] >> 2) & 0x03; 11415 #line 658 "rx-decode.opc" 11416 int rdst AU = op[2] & 0x0f; 11417 if (trace) 11418 { 11419 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11420 "/** 1111 1101 0111 im00 0110rdst emul #%1, %0 */", 11421 op[0], op[1], op[2]); 11422 printf (" im = 0x%x,", im); 11423 printf (" rdst = 0x%x\n", rdst); 11424 } 11425 SYNTAX("emul #%1, %0"); 11426 #line 658 "rx-decode.opc" 11427 ID(emul); DR(rdst); SC(IMMex(im)); 11428 11429 } 11430 break; 11431 case 0x70: 11432 op_semantics_102: 11433 { 11434 /** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */ 11435 #line 670 "rx-decode.opc" 11436 int im AU = (op[1] >> 2) & 0x03; 11437 #line 670 "rx-decode.opc" 11438 int rdst AU = op[2] & 0x0f; 11439 if (trace) 11440 { 11441 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11442 "/** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */", 11443 op[0], op[1], op[2]); 11444 printf (" im = 0x%x,", im); 11445 printf (" rdst = 0x%x\n", rdst); 11446 } 11447 SYNTAX("emulu #%1, %0"); 11448 #line 670 "rx-decode.opc" 11449 ID(emulu); DR(rdst); SC(IMMex(im)); 11450 11451 } 11452 break; 11453 case 0x80: 11454 op_semantics_103: 11455 { 11456 /** 1111 1101 0111 im00 1000rdst div #%1, %0 */ 11457 #line 682 "rx-decode.opc" 11458 int im AU = (op[1] >> 2) & 0x03; 11459 #line 682 "rx-decode.opc" 11460 int rdst AU = op[2] & 0x0f; 11461 if (trace) 11462 { 11463 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11464 "/** 1111 1101 0111 im00 1000rdst div #%1, %0 */", 11465 op[0], op[1], op[2]); 11466 printf (" im = 0x%x,", im); 11467 printf (" rdst = 0x%x\n", rdst); 11468 } 11469 SYNTAX("div #%1, %0"); 11470 #line 682 "rx-decode.opc" 11471 ID(div); DR(rdst); SC(IMMex(im)); F_O___; 11472 11473 } 11474 break; 11475 case 0x90: 11476 op_semantics_104: 11477 { 11478 /** 1111 1101 0111 im00 1001rdst divu #%1, %0 */ 11479 #line 694 "rx-decode.opc" 11480 int im AU = (op[1] >> 2) & 0x03; 11481 #line 694 "rx-decode.opc" 11482 int rdst AU = op[2] & 0x0f; 11483 if (trace) 11484 { 11485 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11486 "/** 1111 1101 0111 im00 1001rdst divu #%1, %0 */", 11487 op[0], op[1], op[2]); 11488 printf (" im = 0x%x,", im); 11489 printf (" rdst = 0x%x\n", rdst); 11490 } 11491 SYNTAX("divu #%1, %0"); 11492 #line 694 "rx-decode.opc" 11493 ID(divu); DR(rdst); SC(IMMex(im)); F_O___; 11494 11495 } 11496 break; 11497 case 0xc0: 11498 op_semantics_105: 11499 { 11500 /** 1111 1101 0111 im00 1100rdst tst #%1, %2 */ 11501 #line 467 "rx-decode.opc" 11502 int im AU = (op[1] >> 2) & 0x03; 11503 #line 467 "rx-decode.opc" 11504 int rdst AU = op[2] & 0x0f; 11505 if (trace) 11506 { 11507 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11508 "/** 1111 1101 0111 im00 1100rdst tst #%1, %2 */", 11509 op[0], op[1], op[2]); 11510 printf (" im = 0x%x,", im); 11511 printf (" rdst = 0x%x\n", rdst); 11512 } 11513 SYNTAX("tst #%1, %2"); 11514 #line 467 "rx-decode.opc" 11515 ID(and); SC(IMMex(im)); S2R(rdst); F__SZ_; 11516 11517 } 11518 break; 11519 case 0xd0: 11520 op_semantics_106: 11521 { 11522 /** 1111 1101 0111 im00 1101rdst xor #%1, %0 */ 11523 #line 446 "rx-decode.opc" 11524 int im AU = (op[1] >> 2) & 0x03; 11525 #line 446 "rx-decode.opc" 11526 int rdst AU = op[2] & 0x0f; 11527 if (trace) 11528 { 11529 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11530 "/** 1111 1101 0111 im00 1101rdst xor #%1, %0 */", 11531 op[0], op[1], op[2]); 11532 printf (" im = 0x%x,", im); 11533 printf (" rdst = 0x%x\n", rdst); 11534 } 11535 SYNTAX("xor #%1, %0"); 11536 #line 446 "rx-decode.opc" 11537 ID(xor); SC(IMMex(im)); DR(rdst); F__SZ_; 11538 11539 } 11540 break; 11541 case 0xe0: 11542 op_semantics_107: 11543 { 11544 /** 1111 1101 0111 im00 1110rdst stz #%1, %0 */ 11545 #line 392 "rx-decode.opc" 11546 int im AU = (op[1] >> 2) & 0x03; 11547 #line 392 "rx-decode.opc" 11548 int rdst AU = op[2] & 0x0f; 11549 if (trace) 11550 { 11551 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11552 "/** 1111 1101 0111 im00 1110rdst stz #%1, %0 */", 11553 op[0], op[1], op[2]); 11554 printf (" im = 0x%x,", im); 11555 printf (" rdst = 0x%x\n", rdst); 11556 } 11557 SYNTAX("stz #%1, %0"); 11558 #line 392 "rx-decode.opc" 11559 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z); 11560 11561 } 11562 break; 11563 case 0xf0: 11564 op_semantics_108: 11565 { 11566 /** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */ 11567 #line 395 "rx-decode.opc" 11568 int im AU = (op[1] >> 2) & 0x03; 11569 #line 395 "rx-decode.opc" 11570 int rdst AU = op[2] & 0x0f; 11571 if (trace) 11572 { 11573 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11574 "/** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */", 11575 op[0], op[1], op[2]); 11576 printf (" im = 0x%x,", im); 11577 printf (" rdst = 0x%x\n", rdst); 11578 } 11579 SYNTAX("stnz #%1, %0"); 11580 #line 395 "rx-decode.opc" 11581 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz); 11582 11583 /*----------------------------------------------------------------------*/ 11584 /* RTSD */ 11585 11586 } 11587 break; 11588 default: UNSUPPORTED(); break; 11589 } 11590 break; 11591 case 0x72: 11592 GETBYTE (); 11593 switch (op[2] & 0xf0) 11594 { 11595 case 0x00: 11596 { 11597 /** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */ 11598 #line 902 "rx-decode.opc" 11599 int rdst AU = op[2] & 0x0f; 11600 if (trace) 11601 { 11602 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11603 "/** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */", 11604 op[0], op[1], op[2]); 11605 printf (" rdst = 0x%x\n", rdst); 11606 } 11607 SYNTAX("fsub #%1, %0"); 11608 #line 902 "rx-decode.opc" 11609 ID(fsub); DR(rdst); SC(IMM(0)); F__SZ_; 11610 11611 } 11612 break; 11613 case 0x10: 11614 { 11615 /** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */ 11616 #line 896 "rx-decode.opc" 11617 int rdst AU = op[2] & 0x0f; 11618 if (trace) 11619 { 11620 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11621 "/** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */", 11622 op[0], op[1], op[2]); 11623 printf (" rdst = 0x%x\n", rdst); 11624 } 11625 SYNTAX("fcmp #%1, %0"); 11626 #line 896 "rx-decode.opc" 11627 ID(fcmp); DR(rdst); SC(IMM(0)); F_OSZ_; 11628 11629 } 11630 break; 11631 case 0x20: 11632 { 11633 /** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */ 11634 #line 890 "rx-decode.opc" 11635 int rdst AU = op[2] & 0x0f; 11636 if (trace) 11637 { 11638 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11639 "/** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */", 11640 op[0], op[1], op[2]); 11641 printf (" rdst = 0x%x\n", rdst); 11642 } 11643 SYNTAX("fadd #%1, %0"); 11644 #line 890 "rx-decode.opc" 11645 ID(fadd); DR(rdst); SC(IMM(0)); F__SZ_; 11646 11647 } 11648 break; 11649 case 0x30: 11650 { 11651 /** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */ 11652 #line 911 "rx-decode.opc" 11653 int rdst AU = op[2] & 0x0f; 11654 if (trace) 11655 { 11656 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11657 "/** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */", 11658 op[0], op[1], op[2]); 11659 printf (" rdst = 0x%x\n", rdst); 11660 } 11661 SYNTAX("fmul #%1, %0"); 11662 #line 911 "rx-decode.opc" 11663 ID(fmul); DR(rdst); SC(IMM(0)); F__SZ_; 11664 11665 } 11666 break; 11667 case 0x40: 11668 { 11669 /** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */ 11670 #line 917 "rx-decode.opc" 11671 int rdst AU = op[2] & 0x0f; 11672 if (trace) 11673 { 11674 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11675 "/** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */", 11676 op[0], op[1], op[2]); 11677 printf (" rdst = 0x%x\n", rdst); 11678 } 11679 SYNTAX("fdiv #%1, %0"); 11680 #line 917 "rx-decode.opc" 11681 ID(fdiv); DR(rdst); SC(IMM(0)); F__SZ_; 11682 11683 } 11684 break; 11685 default: UNSUPPORTED(); break; 11686 } 11687 break; 11688 case 0x73: 11689 GETBYTE (); 11690 switch (op[2] & 0xe0) 11691 { 11692 case 0x00: 11693 op_semantics_109: 11694 { 11695 /** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */ 11696 #line 1007 "rx-decode.opc" 11697 int im AU = (op[1] >> 2) & 0x03; 11698 #line 1007 "rx-decode.opc" 11699 int crdst AU = op[2] & 0x1f; 11700 if (trace) 11701 { 11702 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11703 "/** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */", 11704 op[0], op[1], op[2]); 11705 printf (" im = 0x%x,", im); 11706 printf (" crdst = 0x%x\n", crdst); 11707 } 11708 SYNTAX("mvtc #%1, %0"); 11709 #line 1007 "rx-decode.opc" 11710 ID(mov); SC(IMMex(im)); DR(crdst + 16); 11711 11712 } 11713 break; 11714 default: UNSUPPORTED(); break; 11715 } 11716 break; 11717 case 0x74: 11718 GETBYTE (); 11719 switch (op[2] & 0xf0) 11720 { 11721 case 0x20: 11722 goto op_semantics_98; 11723 break; 11724 case 0x40: 11725 goto op_semantics_99; 11726 break; 11727 case 0x50: 11728 goto op_semantics_100; 11729 break; 11730 case 0x60: 11731 goto op_semantics_101; 11732 break; 11733 case 0x70: 11734 goto op_semantics_102; 11735 break; 11736 case 0x80: 11737 goto op_semantics_103; 11738 break; 11739 case 0x90: 11740 goto op_semantics_104; 11741 break; 11742 case 0xc0: 11743 goto op_semantics_105; 11744 break; 11745 case 0xd0: 11746 goto op_semantics_106; 11747 break; 11748 case 0xe0: 11749 goto op_semantics_107; 11750 break; 11751 case 0xf0: 11752 goto op_semantics_108; 11753 break; 11754 default: UNSUPPORTED(); break; 11755 } 11756 break; 11757 case 0x77: 11758 GETBYTE (); 11759 switch (op[2] & 0xe0) 11760 { 11761 case 0x00: 11762 goto op_semantics_109; 11763 break; 11764 default: UNSUPPORTED(); break; 11765 } 11766 break; 11767 case 0x78: 11768 GETBYTE (); 11769 switch (op[2] & 0xf0) 11770 { 11771 case 0x20: 11772 goto op_semantics_98; 11773 break; 11774 case 0x40: 11775 goto op_semantics_99; 11776 break; 11777 case 0x50: 11778 goto op_semantics_100; 11779 break; 11780 case 0x60: 11781 goto op_semantics_101; 11782 break; 11783 case 0x70: 11784 goto op_semantics_102; 11785 break; 11786 case 0x80: 11787 goto op_semantics_103; 11788 break; 11789 case 0x90: 11790 goto op_semantics_104; 11791 break; 11792 case 0xc0: 11793 goto op_semantics_105; 11794 break; 11795 case 0xd0: 11796 goto op_semantics_106; 11797 break; 11798 case 0xe0: 11799 goto op_semantics_107; 11800 break; 11801 case 0xf0: 11802 goto op_semantics_108; 11803 break; 11804 default: UNSUPPORTED(); break; 11805 } 11806 break; 11807 case 0x7b: 11808 GETBYTE (); 11809 switch (op[2] & 0xe0) 11810 { 11811 case 0x00: 11812 goto op_semantics_109; 11813 break; 11814 default: UNSUPPORTED(); break; 11815 } 11816 break; 11817 case 0x7c: 11818 GETBYTE (); 11819 switch (op[2] & 0xf0) 11820 { 11821 case 0x20: 11822 goto op_semantics_98; 11823 break; 11824 case 0x40: 11825 goto op_semantics_99; 11826 break; 11827 case 0x50: 11828 goto op_semantics_100; 11829 break; 11830 case 0x60: 11831 goto op_semantics_101; 11832 break; 11833 case 0x70: 11834 goto op_semantics_102; 11835 break; 11836 case 0x80: 11837 goto op_semantics_103; 11838 break; 11839 case 0x90: 11840 goto op_semantics_104; 11841 break; 11842 case 0xc0: 11843 goto op_semantics_105; 11844 break; 11845 case 0xd0: 11846 goto op_semantics_106; 11847 break; 11848 case 0xe0: 11849 goto op_semantics_107; 11850 break; 11851 case 0xf0: 11852 goto op_semantics_108; 11853 break; 11854 default: UNSUPPORTED(); break; 11855 } 11856 break; 11857 case 0x7f: 11858 GETBYTE (); 11859 switch (op[2] & 0xe0) 11860 { 11861 case 0x00: 11862 goto op_semantics_109; 11863 break; 11864 default: UNSUPPORTED(); break; 11865 } 11866 break; 11867 case 0x80: 11868 GETBYTE (); 11869 switch (op[2] & 0x00) 11870 { 11871 case 0x00: 11872 op_semantics_110: 11873 { 11874 /** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */ 11875 #line 732 "rx-decode.opc" 11876 int immmm AU = op[1] & 0x1f; 11877 #line 732 "rx-decode.opc" 11878 int rsrc AU = (op[2] >> 4) & 0x0f; 11879 #line 732 "rx-decode.opc" 11880 int rdst AU = op[2] & 0x0f; 11881 if (trace) 11882 { 11883 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11884 "/** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */", 11885 op[0], op[1], op[2]); 11886 printf (" immmm = 0x%x,", immmm); 11887 printf (" rsrc = 0x%x,", rsrc); 11888 printf (" rdst = 0x%x\n", rdst); 11889 } 11890 SYNTAX("shlr #%2, %1, %0"); 11891 #line 732 "rx-decode.opc" 11892 ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F__SZC; 11893 11894 /*----------------------------------------------------------------------*/ 11895 /* ROTATE */ 11896 11897 } 11898 break; 11899 } 11900 break; 11901 case 0x81: 11902 GETBYTE (); 11903 switch (op[2] & 0x00) 11904 { 11905 case 0x00: 11906 goto op_semantics_110; 11907 break; 11908 } 11909 break; 11910 case 0x82: 11911 GETBYTE (); 11912 switch (op[2] & 0x00) 11913 { 11914 case 0x00: 11915 goto op_semantics_110; 11916 break; 11917 } 11918 break; 11919 case 0x83: 11920 GETBYTE (); 11921 switch (op[2] & 0x00) 11922 { 11923 case 0x00: 11924 goto op_semantics_110; 11925 break; 11926 } 11927 break; 11928 case 0x84: 11929 GETBYTE (); 11930 switch (op[2] & 0x00) 11931 { 11932 case 0x00: 11933 goto op_semantics_110; 11934 break; 11935 } 11936 break; 11937 case 0x85: 11938 GETBYTE (); 11939 switch (op[2] & 0x00) 11940 { 11941 case 0x00: 11942 goto op_semantics_110; 11943 break; 11944 } 11945 break; 11946 case 0x86: 11947 GETBYTE (); 11948 switch (op[2] & 0x00) 11949 { 11950 case 0x00: 11951 goto op_semantics_110; 11952 break; 11953 } 11954 break; 11955 case 0x87: 11956 GETBYTE (); 11957 switch (op[2] & 0x00) 11958 { 11959 case 0x00: 11960 goto op_semantics_110; 11961 break; 11962 } 11963 break; 11964 case 0x88: 11965 GETBYTE (); 11966 switch (op[2] & 0x00) 11967 { 11968 case 0x00: 11969 goto op_semantics_110; 11970 break; 11971 } 11972 break; 11973 case 0x89: 11974 GETBYTE (); 11975 switch (op[2] & 0x00) 11976 { 11977 case 0x00: 11978 goto op_semantics_110; 11979 break; 11980 } 11981 break; 11982 case 0x8a: 11983 GETBYTE (); 11984 switch (op[2] & 0x00) 11985 { 11986 case 0x00: 11987 goto op_semantics_110; 11988 break; 11989 } 11990 break; 11991 case 0x8b: 11992 GETBYTE (); 11993 switch (op[2] & 0x00) 11994 { 11995 case 0x00: 11996 goto op_semantics_110; 11997 break; 11998 } 11999 break; 12000 case 0x8c: 12001 GETBYTE (); 12002 switch (op[2] & 0x00) 12003 { 12004 case 0x00: 12005 goto op_semantics_110; 12006 break; 12007 } 12008 break; 12009 case 0x8d: 12010 GETBYTE (); 12011 switch (op[2] & 0x00) 12012 { 12013 case 0x00: 12014 goto op_semantics_110; 12015 break; 12016 } 12017 break; 12018 case 0x8e: 12019 GETBYTE (); 12020 switch (op[2] & 0x00) 12021 { 12022 case 0x00: 12023 goto op_semantics_110; 12024 break; 12025 } 12026 break; 12027 case 0x8f: 12028 GETBYTE (); 12029 switch (op[2] & 0x00) 12030 { 12031 case 0x00: 12032 goto op_semantics_110; 12033 break; 12034 } 12035 break; 12036 case 0x90: 12037 GETBYTE (); 12038 switch (op[2] & 0x00) 12039 { 12040 case 0x00: 12041 goto op_semantics_110; 12042 break; 12043 } 12044 break; 12045 case 0x91: 12046 GETBYTE (); 12047 switch (op[2] & 0x00) 12048 { 12049 case 0x00: 12050 goto op_semantics_110; 12051 break; 12052 } 12053 break; 12054 case 0x92: 12055 GETBYTE (); 12056 switch (op[2] & 0x00) 12057 { 12058 case 0x00: 12059 goto op_semantics_110; 12060 break; 12061 } 12062 break; 12063 case 0x93: 12064 GETBYTE (); 12065 switch (op[2] & 0x00) 12066 { 12067 case 0x00: 12068 goto op_semantics_110; 12069 break; 12070 } 12071 break; 12072 case 0x94: 12073 GETBYTE (); 12074 switch (op[2] & 0x00) 12075 { 12076 case 0x00: 12077 goto op_semantics_110; 12078 break; 12079 } 12080 break; 12081 case 0x95: 12082 GETBYTE (); 12083 switch (op[2] & 0x00) 12084 { 12085 case 0x00: 12086 goto op_semantics_110; 12087 break; 12088 } 12089 break; 12090 case 0x96: 12091 GETBYTE (); 12092 switch (op[2] & 0x00) 12093 { 12094 case 0x00: 12095 goto op_semantics_110; 12096 break; 12097 } 12098 break; 12099 case 0x97: 12100 GETBYTE (); 12101 switch (op[2] & 0x00) 12102 { 12103 case 0x00: 12104 goto op_semantics_110; 12105 break; 12106 } 12107 break; 12108 case 0x98: 12109 GETBYTE (); 12110 switch (op[2] & 0x00) 12111 { 12112 case 0x00: 12113 goto op_semantics_110; 12114 break; 12115 } 12116 break; 12117 case 0x99: 12118 GETBYTE (); 12119 switch (op[2] & 0x00) 12120 { 12121 case 0x00: 12122 goto op_semantics_110; 12123 break; 12124 } 12125 break; 12126 case 0x9a: 12127 GETBYTE (); 12128 switch (op[2] & 0x00) 12129 { 12130 case 0x00: 12131 goto op_semantics_110; 12132 break; 12133 } 12134 break; 12135 case 0x9b: 12136 GETBYTE (); 12137 switch (op[2] & 0x00) 12138 { 12139 case 0x00: 12140 goto op_semantics_110; 12141 break; 12142 } 12143 break; 12144 case 0x9c: 12145 GETBYTE (); 12146 switch (op[2] & 0x00) 12147 { 12148 case 0x00: 12149 goto op_semantics_110; 12150 break; 12151 } 12152 break; 12153 case 0x9d: 12154 GETBYTE (); 12155 switch (op[2] & 0x00) 12156 { 12157 case 0x00: 12158 goto op_semantics_110; 12159 break; 12160 } 12161 break; 12162 case 0x9e: 12163 GETBYTE (); 12164 switch (op[2] & 0x00) 12165 { 12166 case 0x00: 12167 goto op_semantics_110; 12168 break; 12169 } 12170 break; 12171 case 0x9f: 12172 GETBYTE (); 12173 switch (op[2] & 0x00) 12174 { 12175 case 0x00: 12176 goto op_semantics_110; 12177 break; 12178 } 12179 break; 12180 case 0xa0: 12181 GETBYTE (); 12182 switch (op[2] & 0x00) 12183 { 12184 case 0x00: 12185 op_semantics_111: 12186 { 12187 /** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */ 12188 #line 722 "rx-decode.opc" 12189 int immmm AU = op[1] & 0x1f; 12190 #line 722 "rx-decode.opc" 12191 int rsrc AU = (op[2] >> 4) & 0x0f; 12192 #line 722 "rx-decode.opc" 12193 int rdst AU = op[2] & 0x0f; 12194 if (trace) 12195 { 12196 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12197 "/** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */", 12198 op[0], op[1], op[2]); 12199 printf (" immmm = 0x%x,", immmm); 12200 printf (" rsrc = 0x%x,", rsrc); 12201 printf (" rdst = 0x%x\n", rdst); 12202 } 12203 SYNTAX("shar #%2, %1, %0"); 12204 #line 722 "rx-decode.opc" 12205 ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F_0SZC; 12206 12207 12208 } 12209 break; 12210 } 12211 break; 12212 case 0xa1: 12213 GETBYTE (); 12214 switch (op[2] & 0x00) 12215 { 12216 case 0x00: 12217 goto op_semantics_111; 12218 break; 12219 } 12220 break; 12221 case 0xa2: 12222 GETBYTE (); 12223 switch (op[2] & 0x00) 12224 { 12225 case 0x00: 12226 goto op_semantics_111; 12227 break; 12228 } 12229 break; 12230 case 0xa3: 12231 GETBYTE (); 12232 switch (op[2] & 0x00) 12233 { 12234 case 0x00: 12235 goto op_semantics_111; 12236 break; 12237 } 12238 break; 12239 case 0xa4: 12240 GETBYTE (); 12241 switch (op[2] & 0x00) 12242 { 12243 case 0x00: 12244 goto op_semantics_111; 12245 break; 12246 } 12247 break; 12248 case 0xa5: 12249 GETBYTE (); 12250 switch (op[2] & 0x00) 12251 { 12252 case 0x00: 12253 goto op_semantics_111; 12254 break; 12255 } 12256 break; 12257 case 0xa6: 12258 GETBYTE (); 12259 switch (op[2] & 0x00) 12260 { 12261 case 0x00: 12262 goto op_semantics_111; 12263 break; 12264 } 12265 break; 12266 case 0xa7: 12267 GETBYTE (); 12268 switch (op[2] & 0x00) 12269 { 12270 case 0x00: 12271 goto op_semantics_111; 12272 break; 12273 } 12274 break; 12275 case 0xa8: 12276 GETBYTE (); 12277 switch (op[2] & 0x00) 12278 { 12279 case 0x00: 12280 goto op_semantics_111; 12281 break; 12282 } 12283 break; 12284 case 0xa9: 12285 GETBYTE (); 12286 switch (op[2] & 0x00) 12287 { 12288 case 0x00: 12289 goto op_semantics_111; 12290 break; 12291 } 12292 break; 12293 case 0xaa: 12294 GETBYTE (); 12295 switch (op[2] & 0x00) 12296 { 12297 case 0x00: 12298 goto op_semantics_111; 12299 break; 12300 } 12301 break; 12302 case 0xab: 12303 GETBYTE (); 12304 switch (op[2] & 0x00) 12305 { 12306 case 0x00: 12307 goto op_semantics_111; 12308 break; 12309 } 12310 break; 12311 case 0xac: 12312 GETBYTE (); 12313 switch (op[2] & 0x00) 12314 { 12315 case 0x00: 12316 goto op_semantics_111; 12317 break; 12318 } 12319 break; 12320 case 0xad: 12321 GETBYTE (); 12322 switch (op[2] & 0x00) 12323 { 12324 case 0x00: 12325 goto op_semantics_111; 12326 break; 12327 } 12328 break; 12329 case 0xae: 12330 GETBYTE (); 12331 switch (op[2] & 0x00) 12332 { 12333 case 0x00: 12334 goto op_semantics_111; 12335 break; 12336 } 12337 break; 12338 case 0xaf: 12339 GETBYTE (); 12340 switch (op[2] & 0x00) 12341 { 12342 case 0x00: 12343 goto op_semantics_111; 12344 break; 12345 } 12346 break; 12347 case 0xb0: 12348 GETBYTE (); 12349 switch (op[2] & 0x00) 12350 { 12351 case 0x00: 12352 goto op_semantics_111; 12353 break; 12354 } 12355 break; 12356 case 0xb1: 12357 GETBYTE (); 12358 switch (op[2] & 0x00) 12359 { 12360 case 0x00: 12361 goto op_semantics_111; 12362 break; 12363 } 12364 break; 12365 case 0xb2: 12366 GETBYTE (); 12367 switch (op[2] & 0x00) 12368 { 12369 case 0x00: 12370 goto op_semantics_111; 12371 break; 12372 } 12373 break; 12374 case 0xb3: 12375 GETBYTE (); 12376 switch (op[2] & 0x00) 12377 { 12378 case 0x00: 12379 goto op_semantics_111; 12380 break; 12381 } 12382 break; 12383 case 0xb4: 12384 GETBYTE (); 12385 switch (op[2] & 0x00) 12386 { 12387 case 0x00: 12388 goto op_semantics_111; 12389 break; 12390 } 12391 break; 12392 case 0xb5: 12393 GETBYTE (); 12394 switch (op[2] & 0x00) 12395 { 12396 case 0x00: 12397 goto op_semantics_111; 12398 break; 12399 } 12400 break; 12401 case 0xb6: 12402 GETBYTE (); 12403 switch (op[2] & 0x00) 12404 { 12405 case 0x00: 12406 goto op_semantics_111; 12407 break; 12408 } 12409 break; 12410 case 0xb7: 12411 GETBYTE (); 12412 switch (op[2] & 0x00) 12413 { 12414 case 0x00: 12415 goto op_semantics_111; 12416 break; 12417 } 12418 break; 12419 case 0xb8: 12420 GETBYTE (); 12421 switch (op[2] & 0x00) 12422 { 12423 case 0x00: 12424 goto op_semantics_111; 12425 break; 12426 } 12427 break; 12428 case 0xb9: 12429 GETBYTE (); 12430 switch (op[2] & 0x00) 12431 { 12432 case 0x00: 12433 goto op_semantics_111; 12434 break; 12435 } 12436 break; 12437 case 0xba: 12438 GETBYTE (); 12439 switch (op[2] & 0x00) 12440 { 12441 case 0x00: 12442 goto op_semantics_111; 12443 break; 12444 } 12445 break; 12446 case 0xbb: 12447 GETBYTE (); 12448 switch (op[2] & 0x00) 12449 { 12450 case 0x00: 12451 goto op_semantics_111; 12452 break; 12453 } 12454 break; 12455 case 0xbc: 12456 GETBYTE (); 12457 switch (op[2] & 0x00) 12458 { 12459 case 0x00: 12460 goto op_semantics_111; 12461 break; 12462 } 12463 break; 12464 case 0xbd: 12465 GETBYTE (); 12466 switch (op[2] & 0x00) 12467 { 12468 case 0x00: 12469 goto op_semantics_111; 12470 break; 12471 } 12472 break; 12473 case 0xbe: 12474 GETBYTE (); 12475 switch (op[2] & 0x00) 12476 { 12477 case 0x00: 12478 goto op_semantics_111; 12479 break; 12480 } 12481 break; 12482 case 0xbf: 12483 GETBYTE (); 12484 switch (op[2] & 0x00) 12485 { 12486 case 0x00: 12487 goto op_semantics_111; 12488 break; 12489 } 12490 break; 12491 case 0xc0: 12492 GETBYTE (); 12493 switch (op[2] & 0x00) 12494 { 12495 case 0x00: 12496 op_semantics_112: 12497 { 12498 /** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */ 12499 #line 712 "rx-decode.opc" 12500 int immmm AU = op[1] & 0x1f; 12501 #line 712 "rx-decode.opc" 12502 int rsrc AU = (op[2] >> 4) & 0x0f; 12503 #line 712 "rx-decode.opc" 12504 int rdst AU = op[2] & 0x0f; 12505 if (trace) 12506 { 12507 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12508 "/** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */", 12509 op[0], op[1], op[2]); 12510 printf (" immmm = 0x%x,", immmm); 12511 printf (" rsrc = 0x%x,", rsrc); 12512 printf (" rdst = 0x%x\n", rdst); 12513 } 12514 SYNTAX("shll #%2, %1, %0"); 12515 #line 712 "rx-decode.opc" 12516 ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F_OSZC; 12517 12518 12519 } 12520 break; 12521 } 12522 break; 12523 case 0xc1: 12524 GETBYTE (); 12525 switch (op[2] & 0x00) 12526 { 12527 case 0x00: 12528 goto op_semantics_112; 12529 break; 12530 } 12531 break; 12532 case 0xc2: 12533 GETBYTE (); 12534 switch (op[2] & 0x00) 12535 { 12536 case 0x00: 12537 goto op_semantics_112; 12538 break; 12539 } 12540 break; 12541 case 0xc3: 12542 GETBYTE (); 12543 switch (op[2] & 0x00) 12544 { 12545 case 0x00: 12546 goto op_semantics_112; 12547 break; 12548 } 12549 break; 12550 case 0xc4: 12551 GETBYTE (); 12552 switch (op[2] & 0x00) 12553 { 12554 case 0x00: 12555 goto op_semantics_112; 12556 break; 12557 } 12558 break; 12559 case 0xc5: 12560 GETBYTE (); 12561 switch (op[2] & 0x00) 12562 { 12563 case 0x00: 12564 goto op_semantics_112; 12565 break; 12566 } 12567 break; 12568 case 0xc6: 12569 GETBYTE (); 12570 switch (op[2] & 0x00) 12571 { 12572 case 0x00: 12573 goto op_semantics_112; 12574 break; 12575 } 12576 break; 12577 case 0xc7: 12578 GETBYTE (); 12579 switch (op[2] & 0x00) 12580 { 12581 case 0x00: 12582 goto op_semantics_112; 12583 break; 12584 } 12585 break; 12586 case 0xc8: 12587 GETBYTE (); 12588 switch (op[2] & 0x00) 12589 { 12590 case 0x00: 12591 goto op_semantics_112; 12592 break; 12593 } 12594 break; 12595 case 0xc9: 12596 GETBYTE (); 12597 switch (op[2] & 0x00) 12598 { 12599 case 0x00: 12600 goto op_semantics_112; 12601 break; 12602 } 12603 break; 12604 case 0xca: 12605 GETBYTE (); 12606 switch (op[2] & 0x00) 12607 { 12608 case 0x00: 12609 goto op_semantics_112; 12610 break; 12611 } 12612 break; 12613 case 0xcb: 12614 GETBYTE (); 12615 switch (op[2] & 0x00) 12616 { 12617 case 0x00: 12618 goto op_semantics_112; 12619 break; 12620 } 12621 break; 12622 case 0xcc: 12623 GETBYTE (); 12624 switch (op[2] & 0x00) 12625 { 12626 case 0x00: 12627 goto op_semantics_112; 12628 break; 12629 } 12630 break; 12631 case 0xcd: 12632 GETBYTE (); 12633 switch (op[2] & 0x00) 12634 { 12635 case 0x00: 12636 goto op_semantics_112; 12637 break; 12638 } 12639 break; 12640 case 0xce: 12641 GETBYTE (); 12642 switch (op[2] & 0x00) 12643 { 12644 case 0x00: 12645 goto op_semantics_112; 12646 break; 12647 } 12648 break; 12649 case 0xcf: 12650 GETBYTE (); 12651 switch (op[2] & 0x00) 12652 { 12653 case 0x00: 12654 goto op_semantics_112; 12655 break; 12656 } 12657 break; 12658 case 0xd0: 12659 GETBYTE (); 12660 switch (op[2] & 0x00) 12661 { 12662 case 0x00: 12663 goto op_semantics_112; 12664 break; 12665 } 12666 break; 12667 case 0xd1: 12668 GETBYTE (); 12669 switch (op[2] & 0x00) 12670 { 12671 case 0x00: 12672 goto op_semantics_112; 12673 break; 12674 } 12675 break; 12676 case 0xd2: 12677 GETBYTE (); 12678 switch (op[2] & 0x00) 12679 { 12680 case 0x00: 12681 goto op_semantics_112; 12682 break; 12683 } 12684 break; 12685 case 0xd3: 12686 GETBYTE (); 12687 switch (op[2] & 0x00) 12688 { 12689 case 0x00: 12690 goto op_semantics_112; 12691 break; 12692 } 12693 break; 12694 case 0xd4: 12695 GETBYTE (); 12696 switch (op[2] & 0x00) 12697 { 12698 case 0x00: 12699 goto op_semantics_112; 12700 break; 12701 } 12702 break; 12703 case 0xd5: 12704 GETBYTE (); 12705 switch (op[2] & 0x00) 12706 { 12707 case 0x00: 12708 goto op_semantics_112; 12709 break; 12710 } 12711 break; 12712 case 0xd6: 12713 GETBYTE (); 12714 switch (op[2] & 0x00) 12715 { 12716 case 0x00: 12717 goto op_semantics_112; 12718 break; 12719 } 12720 break; 12721 case 0xd7: 12722 GETBYTE (); 12723 switch (op[2] & 0x00) 12724 { 12725 case 0x00: 12726 goto op_semantics_112; 12727 break; 12728 } 12729 break; 12730 case 0xd8: 12731 GETBYTE (); 12732 switch (op[2] & 0x00) 12733 { 12734 case 0x00: 12735 goto op_semantics_112; 12736 break; 12737 } 12738 break; 12739 case 0xd9: 12740 GETBYTE (); 12741 switch (op[2] & 0x00) 12742 { 12743 case 0x00: 12744 goto op_semantics_112; 12745 break; 12746 } 12747 break; 12748 case 0xda: 12749 GETBYTE (); 12750 switch (op[2] & 0x00) 12751 { 12752 case 0x00: 12753 goto op_semantics_112; 12754 break; 12755 } 12756 break; 12757 case 0xdb: 12758 GETBYTE (); 12759 switch (op[2] & 0x00) 12760 { 12761 case 0x00: 12762 goto op_semantics_112; 12763 break; 12764 } 12765 break; 12766 case 0xdc: 12767 GETBYTE (); 12768 switch (op[2] & 0x00) 12769 { 12770 case 0x00: 12771 goto op_semantics_112; 12772 break; 12773 } 12774 break; 12775 case 0xdd: 12776 GETBYTE (); 12777 switch (op[2] & 0x00) 12778 { 12779 case 0x00: 12780 goto op_semantics_112; 12781 break; 12782 } 12783 break; 12784 case 0xde: 12785 GETBYTE (); 12786 switch (op[2] & 0x00) 12787 { 12788 case 0x00: 12789 goto op_semantics_112; 12790 break; 12791 } 12792 break; 12793 case 0xdf: 12794 GETBYTE (); 12795 switch (op[2] & 0x00) 12796 { 12797 case 0x00: 12798 goto op_semantics_112; 12799 break; 12800 } 12801 break; 12802 case 0xe0: 12803 GETBYTE (); 12804 switch (op[2] & 0xf0) 12805 { 12806 case 0x00: 12807 case 0x10: 12808 case 0x20: 12809 case 0x30: 12810 case 0x40: 12811 case 0x50: 12812 case 0x60: 12813 case 0x70: 12814 case 0x80: 12815 case 0x90: 12816 case 0xa0: 12817 case 0xb0: 12818 case 0xc0: 12819 case 0xd0: 12820 case 0xe0: 12821 op_semantics_113: 12822 { 12823 /** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */ 12824 #line 986 "rx-decode.opc" 12825 int bittt AU = op[1] & 0x1f; 12826 #line 986 "rx-decode.opc" 12827 int cond AU = (op[2] >> 4) & 0x0f; 12828 #line 986 "rx-decode.opc" 12829 int rdst AU = op[2] & 0x0f; 12830 if (trace) 12831 { 12832 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12833 "/** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */", 12834 op[0], op[1], op[2]); 12835 printf (" bittt = 0x%x,", bittt); 12836 printf (" cond = 0x%x,", cond); 12837 printf (" rdst = 0x%x\n", rdst); 12838 } 12839 SYNTAX("bm%2 #%1, %0%S0"); 12840 #line 986 "rx-decode.opc" 12841 ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst); 12842 12843 /*----------------------------------------------------------------------*/ 12844 /* CONTROL REGISTERS */ 12845 12846 } 12847 break; 12848 case 0xf0: 12849 op_semantics_114: 12850 { 12851 /** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */ 12852 #line 979 "rx-decode.opc" 12853 int bittt AU = op[1] & 0x1f; 12854 #line 979 "rx-decode.opc" 12855 int rdst AU = op[2] & 0x0f; 12856 if (trace) 12857 { 12858 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12859 "/** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */", 12860 op[0], op[1], op[2]); 12861 printf (" bittt = 0x%x,", bittt); 12862 printf (" rdst = 0x%x\n", rdst); 12863 } 12864 SYNTAX("bnot #%1, %0"); 12865 #line 979 "rx-decode.opc" 12866 ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst); 12867 12868 12869 } 12870 break; 12871 } 12872 break; 12873 case 0xe1: 12874 GETBYTE (); 12875 switch (op[2] & 0xf0) 12876 { 12877 case 0x00: 12878 case 0x10: 12879 case 0x20: 12880 case 0x30: 12881 case 0x40: 12882 case 0x50: 12883 case 0x60: 12884 case 0x70: 12885 case 0x80: 12886 case 0x90: 12887 case 0xa0: 12888 case 0xb0: 12889 case 0xc0: 12890 case 0xd0: 12891 case 0xe0: 12892 goto op_semantics_113; 12893 break; 12894 case 0xf0: 12895 goto op_semantics_114; 12896 break; 12897 } 12898 break; 12899 case 0xe2: 12900 GETBYTE (); 12901 switch (op[2] & 0xf0) 12902 { 12903 case 0x00: 12904 case 0x10: 12905 case 0x20: 12906 case 0x30: 12907 case 0x40: 12908 case 0x50: 12909 case 0x60: 12910 case 0x70: 12911 case 0x80: 12912 case 0x90: 12913 case 0xa0: 12914 case 0xb0: 12915 case 0xc0: 12916 case 0xd0: 12917 case 0xe0: 12918 goto op_semantics_113; 12919 break; 12920 case 0xf0: 12921 goto op_semantics_114; 12922 break; 12923 } 12924 break; 12925 case 0xe3: 12926 GETBYTE (); 12927 switch (op[2] & 0xf0) 12928 { 12929 case 0x00: 12930 case 0x10: 12931 case 0x20: 12932 case 0x30: 12933 case 0x40: 12934 case 0x50: 12935 case 0x60: 12936 case 0x70: 12937 case 0x80: 12938 case 0x90: 12939 case 0xa0: 12940 case 0xb0: 12941 case 0xc0: 12942 case 0xd0: 12943 case 0xe0: 12944 goto op_semantics_113; 12945 break; 12946 case 0xf0: 12947 goto op_semantics_114; 12948 break; 12949 } 12950 break; 12951 case 0xe4: 12952 GETBYTE (); 12953 switch (op[2] & 0xf0) 12954 { 12955 case 0x00: 12956 case 0x10: 12957 case 0x20: 12958 case 0x30: 12959 case 0x40: 12960 case 0x50: 12961 case 0x60: 12962 case 0x70: 12963 case 0x80: 12964 case 0x90: 12965 case 0xa0: 12966 case 0xb0: 12967 case 0xc0: 12968 case 0xd0: 12969 case 0xe0: 12970 goto op_semantics_113; 12971 break; 12972 case 0xf0: 12973 goto op_semantics_114; 12974 break; 12975 } 12976 break; 12977 case 0xe5: 12978 GETBYTE (); 12979 switch (op[2] & 0xf0) 12980 { 12981 case 0x00: 12982 case 0x10: 12983 case 0x20: 12984 case 0x30: 12985 case 0x40: 12986 case 0x50: 12987 case 0x60: 12988 case 0x70: 12989 case 0x80: 12990 case 0x90: 12991 case 0xa0: 12992 case 0xb0: 12993 case 0xc0: 12994 case 0xd0: 12995 case 0xe0: 12996 goto op_semantics_113; 12997 break; 12998 case 0xf0: 12999 goto op_semantics_114; 13000 break; 13001 } 13002 break; 13003 case 0xe6: 13004 GETBYTE (); 13005 switch (op[2] & 0xf0) 13006 { 13007 case 0x00: 13008 case 0x10: 13009 case 0x20: 13010 case 0x30: 13011 case 0x40: 13012 case 0x50: 13013 case 0x60: 13014 case 0x70: 13015 case 0x80: 13016 case 0x90: 13017 case 0xa0: 13018 case 0xb0: 13019 case 0xc0: 13020 case 0xd0: 13021 case 0xe0: 13022 goto op_semantics_113; 13023 break; 13024 case 0xf0: 13025 goto op_semantics_114; 13026 break; 13027 } 13028 break; 13029 case 0xe7: 13030 GETBYTE (); 13031 switch (op[2] & 0xf0) 13032 { 13033 case 0x00: 13034 case 0x10: 13035 case 0x20: 13036 case 0x30: 13037 case 0x40: 13038 case 0x50: 13039 case 0x60: 13040 case 0x70: 13041 case 0x80: 13042 case 0x90: 13043 case 0xa0: 13044 case 0xb0: 13045 case 0xc0: 13046 case 0xd0: 13047 case 0xe0: 13048 goto op_semantics_113; 13049 break; 13050 case 0xf0: 13051 goto op_semantics_114; 13052 break; 13053 } 13054 break; 13055 case 0xe8: 13056 GETBYTE (); 13057 switch (op[2] & 0xf0) 13058 { 13059 case 0x00: 13060 case 0x10: 13061 case 0x20: 13062 case 0x30: 13063 case 0x40: 13064 case 0x50: 13065 case 0x60: 13066 case 0x70: 13067 case 0x80: 13068 case 0x90: 13069 case 0xa0: 13070 case 0xb0: 13071 case 0xc0: 13072 case 0xd0: 13073 case 0xe0: 13074 goto op_semantics_113; 13075 break; 13076 case 0xf0: 13077 goto op_semantics_114; 13078 break; 13079 } 13080 break; 13081 case 0xe9: 13082 GETBYTE (); 13083 switch (op[2] & 0xf0) 13084 { 13085 case 0x00: 13086 case 0x10: 13087 case 0x20: 13088 case 0x30: 13089 case 0x40: 13090 case 0x50: 13091 case 0x60: 13092 case 0x70: 13093 case 0x80: 13094 case 0x90: 13095 case 0xa0: 13096 case 0xb0: 13097 case 0xc0: 13098 case 0xd0: 13099 case 0xe0: 13100 goto op_semantics_113; 13101 break; 13102 case 0xf0: 13103 goto op_semantics_114; 13104 break; 13105 } 13106 break; 13107 case 0xea: 13108 GETBYTE (); 13109 switch (op[2] & 0xf0) 13110 { 13111 case 0x00: 13112 case 0x10: 13113 case 0x20: 13114 case 0x30: 13115 case 0x40: 13116 case 0x50: 13117 case 0x60: 13118 case 0x70: 13119 case 0x80: 13120 case 0x90: 13121 case 0xa0: 13122 case 0xb0: 13123 case 0xc0: 13124 case 0xd0: 13125 case 0xe0: 13126 goto op_semantics_113; 13127 break; 13128 case 0xf0: 13129 goto op_semantics_114; 13130 break; 13131 } 13132 break; 13133 case 0xeb: 13134 GETBYTE (); 13135 switch (op[2] & 0xf0) 13136 { 13137 case 0x00: 13138 case 0x10: 13139 case 0x20: 13140 case 0x30: 13141 case 0x40: 13142 case 0x50: 13143 case 0x60: 13144 case 0x70: 13145 case 0x80: 13146 case 0x90: 13147 case 0xa0: 13148 case 0xb0: 13149 case 0xc0: 13150 case 0xd0: 13151 case 0xe0: 13152 goto op_semantics_113; 13153 break; 13154 case 0xf0: 13155 goto op_semantics_114; 13156 break; 13157 } 13158 break; 13159 case 0xec: 13160 GETBYTE (); 13161 switch (op[2] & 0xf0) 13162 { 13163 case 0x00: 13164 case 0x10: 13165 case 0x20: 13166 case 0x30: 13167 case 0x40: 13168 case 0x50: 13169 case 0x60: 13170 case 0x70: 13171 case 0x80: 13172 case 0x90: 13173 case 0xa0: 13174 case 0xb0: 13175 case 0xc0: 13176 case 0xd0: 13177 case 0xe0: 13178 goto op_semantics_113; 13179 break; 13180 case 0xf0: 13181 goto op_semantics_114; 13182 break; 13183 } 13184 break; 13185 case 0xed: 13186 GETBYTE (); 13187 switch (op[2] & 0xf0) 13188 { 13189 case 0x00: 13190 case 0x10: 13191 case 0x20: 13192 case 0x30: 13193 case 0x40: 13194 case 0x50: 13195 case 0x60: 13196 case 0x70: 13197 case 0x80: 13198 case 0x90: 13199 case 0xa0: 13200 case 0xb0: 13201 case 0xc0: 13202 case 0xd0: 13203 case 0xe0: 13204 goto op_semantics_113; 13205 break; 13206 case 0xf0: 13207 goto op_semantics_114; 13208 break; 13209 } 13210 break; 13211 case 0xee: 13212 GETBYTE (); 13213 switch (op[2] & 0xf0) 13214 { 13215 case 0x00: 13216 case 0x10: 13217 case 0x20: 13218 case 0x30: 13219 case 0x40: 13220 case 0x50: 13221 case 0x60: 13222 case 0x70: 13223 case 0x80: 13224 case 0x90: 13225 case 0xa0: 13226 case 0xb0: 13227 case 0xc0: 13228 case 0xd0: 13229 case 0xe0: 13230 goto op_semantics_113; 13231 break; 13232 case 0xf0: 13233 goto op_semantics_114; 13234 break; 13235 } 13236 break; 13237 case 0xef: 13238 GETBYTE (); 13239 switch (op[2] & 0xf0) 13240 { 13241 case 0x00: 13242 case 0x10: 13243 case 0x20: 13244 case 0x30: 13245 case 0x40: 13246 case 0x50: 13247 case 0x60: 13248 case 0x70: 13249 case 0x80: 13250 case 0x90: 13251 case 0xa0: 13252 case 0xb0: 13253 case 0xc0: 13254 case 0xd0: 13255 case 0xe0: 13256 goto op_semantics_113; 13257 break; 13258 case 0xf0: 13259 goto op_semantics_114; 13260 break; 13261 } 13262 break; 13263 case 0xf0: 13264 GETBYTE (); 13265 switch (op[2] & 0xf0) 13266 { 13267 case 0x00: 13268 case 0x10: 13269 case 0x20: 13270 case 0x30: 13271 case 0x40: 13272 case 0x50: 13273 case 0x60: 13274 case 0x70: 13275 case 0x80: 13276 case 0x90: 13277 case 0xa0: 13278 case 0xb0: 13279 case 0xc0: 13280 case 0xd0: 13281 case 0xe0: 13282 goto op_semantics_113; 13283 break; 13284 case 0xf0: 13285 goto op_semantics_114; 13286 break; 13287 } 13288 break; 13289 case 0xf1: 13290 GETBYTE (); 13291 switch (op[2] & 0xf0) 13292 { 13293 case 0x00: 13294 case 0x10: 13295 case 0x20: 13296 case 0x30: 13297 case 0x40: 13298 case 0x50: 13299 case 0x60: 13300 case 0x70: 13301 case 0x80: 13302 case 0x90: 13303 case 0xa0: 13304 case 0xb0: 13305 case 0xc0: 13306 case 0xd0: 13307 case 0xe0: 13308 goto op_semantics_113; 13309 break; 13310 case 0xf0: 13311 goto op_semantics_114; 13312 break; 13313 } 13314 break; 13315 case 0xf2: 13316 GETBYTE (); 13317 switch (op[2] & 0xf0) 13318 { 13319 case 0x00: 13320 case 0x10: 13321 case 0x20: 13322 case 0x30: 13323 case 0x40: 13324 case 0x50: 13325 case 0x60: 13326 case 0x70: 13327 case 0x80: 13328 case 0x90: 13329 case 0xa0: 13330 case 0xb0: 13331 case 0xc0: 13332 case 0xd0: 13333 case 0xe0: 13334 goto op_semantics_113; 13335 break; 13336 case 0xf0: 13337 goto op_semantics_114; 13338 break; 13339 } 13340 break; 13341 case 0xf3: 13342 GETBYTE (); 13343 switch (op[2] & 0xf0) 13344 { 13345 case 0x00: 13346 case 0x10: 13347 case 0x20: 13348 case 0x30: 13349 case 0x40: 13350 case 0x50: 13351 case 0x60: 13352 case 0x70: 13353 case 0x80: 13354 case 0x90: 13355 case 0xa0: 13356 case 0xb0: 13357 case 0xc0: 13358 case 0xd0: 13359 case 0xe0: 13360 goto op_semantics_113; 13361 break; 13362 case 0xf0: 13363 goto op_semantics_114; 13364 break; 13365 } 13366 break; 13367 case 0xf4: 13368 GETBYTE (); 13369 switch (op[2] & 0xf0) 13370 { 13371 case 0x00: 13372 case 0x10: 13373 case 0x20: 13374 case 0x30: 13375 case 0x40: 13376 case 0x50: 13377 case 0x60: 13378 case 0x70: 13379 case 0x80: 13380 case 0x90: 13381 case 0xa0: 13382 case 0xb0: 13383 case 0xc0: 13384 case 0xd0: 13385 case 0xe0: 13386 goto op_semantics_113; 13387 break; 13388 case 0xf0: 13389 goto op_semantics_114; 13390 break; 13391 } 13392 break; 13393 case 0xf5: 13394 GETBYTE (); 13395 switch (op[2] & 0xf0) 13396 { 13397 case 0x00: 13398 case 0x10: 13399 case 0x20: 13400 case 0x30: 13401 case 0x40: 13402 case 0x50: 13403 case 0x60: 13404 case 0x70: 13405 case 0x80: 13406 case 0x90: 13407 case 0xa0: 13408 case 0xb0: 13409 case 0xc0: 13410 case 0xd0: 13411 case 0xe0: 13412 goto op_semantics_113; 13413 break; 13414 case 0xf0: 13415 goto op_semantics_114; 13416 break; 13417 } 13418 break; 13419 case 0xf6: 13420 GETBYTE (); 13421 switch (op[2] & 0xf0) 13422 { 13423 case 0x00: 13424 case 0x10: 13425 case 0x20: 13426 case 0x30: 13427 case 0x40: 13428 case 0x50: 13429 case 0x60: 13430 case 0x70: 13431 case 0x80: 13432 case 0x90: 13433 case 0xa0: 13434 case 0xb0: 13435 case 0xc0: 13436 case 0xd0: 13437 case 0xe0: 13438 goto op_semantics_113; 13439 break; 13440 case 0xf0: 13441 goto op_semantics_114; 13442 break; 13443 } 13444 break; 13445 case 0xf7: 13446 GETBYTE (); 13447 switch (op[2] & 0xf0) 13448 { 13449 case 0x00: 13450 case 0x10: 13451 case 0x20: 13452 case 0x30: 13453 case 0x40: 13454 case 0x50: 13455 case 0x60: 13456 case 0x70: 13457 case 0x80: 13458 case 0x90: 13459 case 0xa0: 13460 case 0xb0: 13461 case 0xc0: 13462 case 0xd0: 13463 case 0xe0: 13464 goto op_semantics_113; 13465 break; 13466 case 0xf0: 13467 goto op_semantics_114; 13468 break; 13469 } 13470 break; 13471 case 0xf8: 13472 GETBYTE (); 13473 switch (op[2] & 0xf0) 13474 { 13475 case 0x00: 13476 case 0x10: 13477 case 0x20: 13478 case 0x30: 13479 case 0x40: 13480 case 0x50: 13481 case 0x60: 13482 case 0x70: 13483 case 0x80: 13484 case 0x90: 13485 case 0xa0: 13486 case 0xb0: 13487 case 0xc0: 13488 case 0xd0: 13489 case 0xe0: 13490 goto op_semantics_113; 13491 break; 13492 case 0xf0: 13493 goto op_semantics_114; 13494 break; 13495 } 13496 break; 13497 case 0xf9: 13498 GETBYTE (); 13499 switch (op[2] & 0xf0) 13500 { 13501 case 0x00: 13502 case 0x10: 13503 case 0x20: 13504 case 0x30: 13505 case 0x40: 13506 case 0x50: 13507 case 0x60: 13508 case 0x70: 13509 case 0x80: 13510 case 0x90: 13511 case 0xa0: 13512 case 0xb0: 13513 case 0xc0: 13514 case 0xd0: 13515 case 0xe0: 13516 goto op_semantics_113; 13517 break; 13518 case 0xf0: 13519 goto op_semantics_114; 13520 break; 13521 } 13522 break; 13523 case 0xfa: 13524 GETBYTE (); 13525 switch (op[2] & 0xf0) 13526 { 13527 case 0x00: 13528 case 0x10: 13529 case 0x20: 13530 case 0x30: 13531 case 0x40: 13532 case 0x50: 13533 case 0x60: 13534 case 0x70: 13535 case 0x80: 13536 case 0x90: 13537 case 0xa0: 13538 case 0xb0: 13539 case 0xc0: 13540 case 0xd0: 13541 case 0xe0: 13542 goto op_semantics_113; 13543 break; 13544 case 0xf0: 13545 goto op_semantics_114; 13546 break; 13547 } 13548 break; 13549 case 0xfb: 13550 GETBYTE (); 13551 switch (op[2] & 0xf0) 13552 { 13553 case 0x00: 13554 case 0x10: 13555 case 0x20: 13556 case 0x30: 13557 case 0x40: 13558 case 0x50: 13559 case 0x60: 13560 case 0x70: 13561 case 0x80: 13562 case 0x90: 13563 case 0xa0: 13564 case 0xb0: 13565 case 0xc0: 13566 case 0xd0: 13567 case 0xe0: 13568 goto op_semantics_113; 13569 break; 13570 case 0xf0: 13571 goto op_semantics_114; 13572 break; 13573 } 13574 break; 13575 case 0xfc: 13576 GETBYTE (); 13577 switch (op[2] & 0xf0) 13578 { 13579 case 0x00: 13580 case 0x10: 13581 case 0x20: 13582 case 0x30: 13583 case 0x40: 13584 case 0x50: 13585 case 0x60: 13586 case 0x70: 13587 case 0x80: 13588 case 0x90: 13589 case 0xa0: 13590 case 0xb0: 13591 case 0xc0: 13592 case 0xd0: 13593 case 0xe0: 13594 goto op_semantics_113; 13595 break; 13596 case 0xf0: 13597 goto op_semantics_114; 13598 break; 13599 } 13600 break; 13601 case 0xfd: 13602 GETBYTE (); 13603 switch (op[2] & 0xf0) 13604 { 13605 case 0x00: 13606 case 0x10: 13607 case 0x20: 13608 case 0x30: 13609 case 0x40: 13610 case 0x50: 13611 case 0x60: 13612 case 0x70: 13613 case 0x80: 13614 case 0x90: 13615 case 0xa0: 13616 case 0xb0: 13617 case 0xc0: 13618 case 0xd0: 13619 case 0xe0: 13620 goto op_semantics_113; 13621 break; 13622 case 0xf0: 13623 goto op_semantics_114; 13624 break; 13625 } 13626 break; 13627 case 0xfe: 13628 GETBYTE (); 13629 switch (op[2] & 0xf0) 13630 { 13631 case 0x00: 13632 case 0x10: 13633 case 0x20: 13634 case 0x30: 13635 case 0x40: 13636 case 0x50: 13637 case 0x60: 13638 case 0x70: 13639 case 0x80: 13640 case 0x90: 13641 case 0xa0: 13642 case 0xb0: 13643 case 0xc0: 13644 case 0xd0: 13645 case 0xe0: 13646 goto op_semantics_113; 13647 break; 13648 case 0xf0: 13649 goto op_semantics_114; 13650 break; 13651 } 13652 break; 13653 case 0xff: 13654 GETBYTE (); 13655 switch (op[2] & 0xf0) 13656 { 13657 case 0x00: 13658 case 0x10: 13659 case 0x20: 13660 case 0x30: 13661 case 0x40: 13662 case 0x50: 13663 case 0x60: 13664 case 0x70: 13665 case 0x80: 13666 case 0x90: 13667 case 0xa0: 13668 case 0xb0: 13669 case 0xc0: 13670 case 0xd0: 13671 case 0xe0: 13672 goto op_semantics_113; 13673 break; 13674 case 0xf0: 13675 goto op_semantics_114; 13676 break; 13677 } 13678 break; 13679 default: UNSUPPORTED(); break; 13680 } 13681 break; 13682 case 0xfe: 13683 GETBYTE (); 13684 switch (op[1] & 0xff) 13685 { 13686 case 0x00: 13687 GETBYTE (); 13688 switch (op[2] & 0x00) 13689 { 13690 case 0x00: 13691 op_semantics_115: 13692 { 13693 /** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */ 13694 #line 338 "rx-decode.opc" 13695 int sz AU = (op[1] >> 4) & 0x03; 13696 #line 338 "rx-decode.opc" 13697 int isrc AU = op[1] & 0x0f; 13698 #line 338 "rx-decode.opc" 13699 int bsrc AU = (op[2] >> 4) & 0x0f; 13700 #line 338 "rx-decode.opc" 13701 int rdst AU = op[2] & 0x0f; 13702 if (trace) 13703 { 13704 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13705 "/** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */", 13706 op[0], op[1], op[2]); 13707 printf (" sz = 0x%x,", sz); 13708 printf (" isrc = 0x%x,", isrc); 13709 printf (" bsrc = 0x%x,", bsrc); 13710 printf (" rdst = 0x%x\n", rdst); 13711 } 13712 SYNTAX("mov%s %0, [%1, %2]"); 13713 #line 338 "rx-decode.opc" 13714 ID(movbir); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____; 13715 13716 } 13717 break; 13718 } 13719 break; 13720 case 0x01: 13721 GETBYTE (); 13722 switch (op[2] & 0x00) 13723 { 13724 case 0x00: 13725 goto op_semantics_115; 13726 break; 13727 } 13728 break; 13729 case 0x02: 13730 GETBYTE (); 13731 switch (op[2] & 0x00) 13732 { 13733 case 0x00: 13734 goto op_semantics_115; 13735 break; 13736 } 13737 break; 13738 case 0x03: 13739 GETBYTE (); 13740 switch (op[2] & 0x00) 13741 { 13742 case 0x00: 13743 goto op_semantics_115; 13744 break; 13745 } 13746 break; 13747 case 0x04: 13748 GETBYTE (); 13749 switch (op[2] & 0x00) 13750 { 13751 case 0x00: 13752 goto op_semantics_115; 13753 break; 13754 } 13755 break; 13756 case 0x05: 13757 GETBYTE (); 13758 switch (op[2] & 0x00) 13759 { 13760 case 0x00: 13761 goto op_semantics_115; 13762 break; 13763 } 13764 break; 13765 case 0x06: 13766 GETBYTE (); 13767 switch (op[2] & 0x00) 13768 { 13769 case 0x00: 13770 goto op_semantics_115; 13771 break; 13772 } 13773 break; 13774 case 0x07: 13775 GETBYTE (); 13776 switch (op[2] & 0x00) 13777 { 13778 case 0x00: 13779 goto op_semantics_115; 13780 break; 13781 } 13782 break; 13783 case 0x08: 13784 GETBYTE (); 13785 switch (op[2] & 0x00) 13786 { 13787 case 0x00: 13788 goto op_semantics_115; 13789 break; 13790 } 13791 break; 13792 case 0x09: 13793 GETBYTE (); 13794 switch (op[2] & 0x00) 13795 { 13796 case 0x00: 13797 goto op_semantics_115; 13798 break; 13799 } 13800 break; 13801 case 0x0a: 13802 GETBYTE (); 13803 switch (op[2] & 0x00) 13804 { 13805 case 0x00: 13806 goto op_semantics_115; 13807 break; 13808 } 13809 break; 13810 case 0x0b: 13811 GETBYTE (); 13812 switch (op[2] & 0x00) 13813 { 13814 case 0x00: 13815 goto op_semantics_115; 13816 break; 13817 } 13818 break; 13819 case 0x0c: 13820 GETBYTE (); 13821 switch (op[2] & 0x00) 13822 { 13823 case 0x00: 13824 goto op_semantics_115; 13825 break; 13826 } 13827 break; 13828 case 0x0d: 13829 GETBYTE (); 13830 switch (op[2] & 0x00) 13831 { 13832 case 0x00: 13833 goto op_semantics_115; 13834 break; 13835 } 13836 break; 13837 case 0x0e: 13838 GETBYTE (); 13839 switch (op[2] & 0x00) 13840 { 13841 case 0x00: 13842 goto op_semantics_115; 13843 break; 13844 } 13845 break; 13846 case 0x0f: 13847 GETBYTE (); 13848 switch (op[2] & 0x00) 13849 { 13850 case 0x00: 13851 goto op_semantics_115; 13852 break; 13853 } 13854 break; 13855 case 0x10: 13856 GETBYTE (); 13857 switch (op[2] & 0x00) 13858 { 13859 case 0x00: 13860 goto op_semantics_115; 13861 break; 13862 } 13863 break; 13864 case 0x11: 13865 GETBYTE (); 13866 switch (op[2] & 0x00) 13867 { 13868 case 0x00: 13869 goto op_semantics_115; 13870 break; 13871 } 13872 break; 13873 case 0x12: 13874 GETBYTE (); 13875 switch (op[2] & 0x00) 13876 { 13877 case 0x00: 13878 goto op_semantics_115; 13879 break; 13880 } 13881 break; 13882 case 0x13: 13883 GETBYTE (); 13884 switch (op[2] & 0x00) 13885 { 13886 case 0x00: 13887 goto op_semantics_115; 13888 break; 13889 } 13890 break; 13891 case 0x14: 13892 GETBYTE (); 13893 switch (op[2] & 0x00) 13894 { 13895 case 0x00: 13896 goto op_semantics_115; 13897 break; 13898 } 13899 break; 13900 case 0x15: 13901 GETBYTE (); 13902 switch (op[2] & 0x00) 13903 { 13904 case 0x00: 13905 goto op_semantics_115; 13906 break; 13907 } 13908 break; 13909 case 0x16: 13910 GETBYTE (); 13911 switch (op[2] & 0x00) 13912 { 13913 case 0x00: 13914 goto op_semantics_115; 13915 break; 13916 } 13917 break; 13918 case 0x17: 13919 GETBYTE (); 13920 switch (op[2] & 0x00) 13921 { 13922 case 0x00: 13923 goto op_semantics_115; 13924 break; 13925 } 13926 break; 13927 case 0x18: 13928 GETBYTE (); 13929 switch (op[2] & 0x00) 13930 { 13931 case 0x00: 13932 goto op_semantics_115; 13933 break; 13934 } 13935 break; 13936 case 0x19: 13937 GETBYTE (); 13938 switch (op[2] & 0x00) 13939 { 13940 case 0x00: 13941 goto op_semantics_115; 13942 break; 13943 } 13944 break; 13945 case 0x1a: 13946 GETBYTE (); 13947 switch (op[2] & 0x00) 13948 { 13949 case 0x00: 13950 goto op_semantics_115; 13951 break; 13952 } 13953 break; 13954 case 0x1b: 13955 GETBYTE (); 13956 switch (op[2] & 0x00) 13957 { 13958 case 0x00: 13959 goto op_semantics_115; 13960 break; 13961 } 13962 break; 13963 case 0x1c: 13964 GETBYTE (); 13965 switch (op[2] & 0x00) 13966 { 13967 case 0x00: 13968 goto op_semantics_115; 13969 break; 13970 } 13971 break; 13972 case 0x1d: 13973 GETBYTE (); 13974 switch (op[2] & 0x00) 13975 { 13976 case 0x00: 13977 goto op_semantics_115; 13978 break; 13979 } 13980 break; 13981 case 0x1e: 13982 GETBYTE (); 13983 switch (op[2] & 0x00) 13984 { 13985 case 0x00: 13986 goto op_semantics_115; 13987 break; 13988 } 13989 break; 13990 case 0x1f: 13991 GETBYTE (); 13992 switch (op[2] & 0x00) 13993 { 13994 case 0x00: 13995 goto op_semantics_115; 13996 break; 13997 } 13998 break; 13999 case 0x20: 14000 GETBYTE (); 14001 switch (op[2] & 0x00) 14002 { 14003 case 0x00: 14004 goto op_semantics_115; 14005 break; 14006 } 14007 break; 14008 case 0x21: 14009 GETBYTE (); 14010 switch (op[2] & 0x00) 14011 { 14012 case 0x00: 14013 goto op_semantics_115; 14014 break; 14015 } 14016 break; 14017 case 0x22: 14018 GETBYTE (); 14019 switch (op[2] & 0x00) 14020 { 14021 case 0x00: 14022 goto op_semantics_115; 14023 break; 14024 } 14025 break; 14026 case 0x23: 14027 GETBYTE (); 14028 switch (op[2] & 0x00) 14029 { 14030 case 0x00: 14031 goto op_semantics_115; 14032 break; 14033 } 14034 break; 14035 case 0x24: 14036 GETBYTE (); 14037 switch (op[2] & 0x00) 14038 { 14039 case 0x00: 14040 goto op_semantics_115; 14041 break; 14042 } 14043 break; 14044 case 0x25: 14045 GETBYTE (); 14046 switch (op[2] & 0x00) 14047 { 14048 case 0x00: 14049 goto op_semantics_115; 14050 break; 14051 } 14052 break; 14053 case 0x26: 14054 GETBYTE (); 14055 switch (op[2] & 0x00) 14056 { 14057 case 0x00: 14058 goto op_semantics_115; 14059 break; 14060 } 14061 break; 14062 case 0x27: 14063 GETBYTE (); 14064 switch (op[2] & 0x00) 14065 { 14066 case 0x00: 14067 goto op_semantics_115; 14068 break; 14069 } 14070 break; 14071 case 0x28: 14072 GETBYTE (); 14073 switch (op[2] & 0x00) 14074 { 14075 case 0x00: 14076 goto op_semantics_115; 14077 break; 14078 } 14079 break; 14080 case 0x29: 14081 GETBYTE (); 14082 switch (op[2] & 0x00) 14083 { 14084 case 0x00: 14085 goto op_semantics_115; 14086 break; 14087 } 14088 break; 14089 case 0x2a: 14090 GETBYTE (); 14091 switch (op[2] & 0x00) 14092 { 14093 case 0x00: 14094 goto op_semantics_115; 14095 break; 14096 } 14097 break; 14098 case 0x2b: 14099 GETBYTE (); 14100 switch (op[2] & 0x00) 14101 { 14102 case 0x00: 14103 goto op_semantics_115; 14104 break; 14105 } 14106 break; 14107 case 0x2c: 14108 GETBYTE (); 14109 switch (op[2] & 0x00) 14110 { 14111 case 0x00: 14112 goto op_semantics_115; 14113 break; 14114 } 14115 break; 14116 case 0x2d: 14117 GETBYTE (); 14118 switch (op[2] & 0x00) 14119 { 14120 case 0x00: 14121 goto op_semantics_115; 14122 break; 14123 } 14124 break; 14125 case 0x2e: 14126 GETBYTE (); 14127 switch (op[2] & 0x00) 14128 { 14129 case 0x00: 14130 goto op_semantics_115; 14131 break; 14132 } 14133 break; 14134 case 0x2f: 14135 GETBYTE (); 14136 switch (op[2] & 0x00) 14137 { 14138 case 0x00: 14139 goto op_semantics_115; 14140 break; 14141 } 14142 break; 14143 case 0x40: 14144 GETBYTE (); 14145 switch (op[2] & 0x00) 14146 { 14147 case 0x00: 14148 op_semantics_116: 14149 { 14150 /** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */ 14151 #line 335 "rx-decode.opc" 14152 int sz AU = (op[1] >> 4) & 0x03; 14153 #line 335 "rx-decode.opc" 14154 int isrc AU = op[1] & 0x0f; 14155 #line 335 "rx-decode.opc" 14156 int bsrc AU = (op[2] >> 4) & 0x0f; 14157 #line 335 "rx-decode.opc" 14158 int rdst AU = op[2] & 0x0f; 14159 if (trace) 14160 { 14161 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 14162 "/** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */", 14163 op[0], op[1], op[2]); 14164 printf (" sz = 0x%x,", sz); 14165 printf (" isrc = 0x%x,", isrc); 14166 printf (" bsrc = 0x%x,", bsrc); 14167 printf (" rdst = 0x%x\n", rdst); 14168 } 14169 SYNTAX("mov%s [%1, %2], %0"); 14170 #line 335 "rx-decode.opc" 14171 ID(movbi); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____; 14172 14173 } 14174 break; 14175 } 14176 break; 14177 case 0x41: 14178 GETBYTE (); 14179 switch (op[2] & 0x00) 14180 { 14181 case 0x00: 14182 goto op_semantics_116; 14183 break; 14184 } 14185 break; 14186 case 0x42: 14187 GETBYTE (); 14188 switch (op[2] & 0x00) 14189 { 14190 case 0x00: 14191 goto op_semantics_116; 14192 break; 14193 } 14194 break; 14195 case 0x43: 14196 GETBYTE (); 14197 switch (op[2] & 0x00) 14198 { 14199 case 0x00: 14200 goto op_semantics_116; 14201 break; 14202 } 14203 break; 14204 case 0x44: 14205 GETBYTE (); 14206 switch (op[2] & 0x00) 14207 { 14208 case 0x00: 14209 goto op_semantics_116; 14210 break; 14211 } 14212 break; 14213 case 0x45: 14214 GETBYTE (); 14215 switch (op[2] & 0x00) 14216 { 14217 case 0x00: 14218 goto op_semantics_116; 14219 break; 14220 } 14221 break; 14222 case 0x46: 14223 GETBYTE (); 14224 switch (op[2] & 0x00) 14225 { 14226 case 0x00: 14227 goto op_semantics_116; 14228 break; 14229 } 14230 break; 14231 case 0x47: 14232 GETBYTE (); 14233 switch (op[2] & 0x00) 14234 { 14235 case 0x00: 14236 goto op_semantics_116; 14237 break; 14238 } 14239 break; 14240 case 0x48: 14241 GETBYTE (); 14242 switch (op[2] & 0x00) 14243 { 14244 case 0x00: 14245 goto op_semantics_116; 14246 break; 14247 } 14248 break; 14249 case 0x49: 14250 GETBYTE (); 14251 switch (op[2] & 0x00) 14252 { 14253 case 0x00: 14254 goto op_semantics_116; 14255 break; 14256 } 14257 break; 14258 case 0x4a: 14259 GETBYTE (); 14260 switch (op[2] & 0x00) 14261 { 14262 case 0x00: 14263 goto op_semantics_116; 14264 break; 14265 } 14266 break; 14267 case 0x4b: 14268 GETBYTE (); 14269 switch (op[2] & 0x00) 14270 { 14271 case 0x00: 14272 goto op_semantics_116; 14273 break; 14274 } 14275 break; 14276 case 0x4c: 14277 GETBYTE (); 14278 switch (op[2] & 0x00) 14279 { 14280 case 0x00: 14281 goto op_semantics_116; 14282 break; 14283 } 14284 break; 14285 case 0x4d: 14286 GETBYTE (); 14287 switch (op[2] & 0x00) 14288 { 14289 case 0x00: 14290 goto op_semantics_116; 14291 break; 14292 } 14293 break; 14294 case 0x4e: 14295 GETBYTE (); 14296 switch (op[2] & 0x00) 14297 { 14298 case 0x00: 14299 goto op_semantics_116; 14300 break; 14301 } 14302 break; 14303 case 0x4f: 14304 GETBYTE (); 14305 switch (op[2] & 0x00) 14306 { 14307 case 0x00: 14308 goto op_semantics_116; 14309 break; 14310 } 14311 break; 14312 case 0x50: 14313 GETBYTE (); 14314 switch (op[2] & 0x00) 14315 { 14316 case 0x00: 14317 goto op_semantics_116; 14318 break; 14319 } 14320 break; 14321 case 0x51: 14322 GETBYTE (); 14323 switch (op[2] & 0x00) 14324 { 14325 case 0x00: 14326 goto op_semantics_116; 14327 break; 14328 } 14329 break; 14330 case 0x52: 14331 GETBYTE (); 14332 switch (op[2] & 0x00) 14333 { 14334 case 0x00: 14335 goto op_semantics_116; 14336 break; 14337 } 14338 break; 14339 case 0x53: 14340 GETBYTE (); 14341 switch (op[2] & 0x00) 14342 { 14343 case 0x00: 14344 goto op_semantics_116; 14345 break; 14346 } 14347 break; 14348 case 0x54: 14349 GETBYTE (); 14350 switch (op[2] & 0x00) 14351 { 14352 case 0x00: 14353 goto op_semantics_116; 14354 break; 14355 } 14356 break; 14357 case 0x55: 14358 GETBYTE (); 14359 switch (op[2] & 0x00) 14360 { 14361 case 0x00: 14362 goto op_semantics_116; 14363 break; 14364 } 14365 break; 14366 case 0x56: 14367 GETBYTE (); 14368 switch (op[2] & 0x00) 14369 { 14370 case 0x00: 14371 goto op_semantics_116; 14372 break; 14373 } 14374 break; 14375 case 0x57: 14376 GETBYTE (); 14377 switch (op[2] & 0x00) 14378 { 14379 case 0x00: 14380 goto op_semantics_116; 14381 break; 14382 } 14383 break; 14384 case 0x58: 14385 GETBYTE (); 14386 switch (op[2] & 0x00) 14387 { 14388 case 0x00: 14389 goto op_semantics_116; 14390 break; 14391 } 14392 break; 14393 case 0x59: 14394 GETBYTE (); 14395 switch (op[2] & 0x00) 14396 { 14397 case 0x00: 14398 goto op_semantics_116; 14399 break; 14400 } 14401 break; 14402 case 0x5a: 14403 GETBYTE (); 14404 switch (op[2] & 0x00) 14405 { 14406 case 0x00: 14407 goto op_semantics_116; 14408 break; 14409 } 14410 break; 14411 case 0x5b: 14412 GETBYTE (); 14413 switch (op[2] & 0x00) 14414 { 14415 case 0x00: 14416 goto op_semantics_116; 14417 break; 14418 } 14419 break; 14420 case 0x5c: 14421 GETBYTE (); 14422 switch (op[2] & 0x00) 14423 { 14424 case 0x00: 14425 goto op_semantics_116; 14426 break; 14427 } 14428 break; 14429 case 0x5d: 14430 GETBYTE (); 14431 switch (op[2] & 0x00) 14432 { 14433 case 0x00: 14434 goto op_semantics_116; 14435 break; 14436 } 14437 break; 14438 case 0x5e: 14439 GETBYTE (); 14440 switch (op[2] & 0x00) 14441 { 14442 case 0x00: 14443 goto op_semantics_116; 14444 break; 14445 } 14446 break; 14447 case 0x5f: 14448 GETBYTE (); 14449 switch (op[2] & 0x00) 14450 { 14451 case 0x00: 14452 goto op_semantics_116; 14453 break; 14454 } 14455 break; 14456 case 0x60: 14457 GETBYTE (); 14458 switch (op[2] & 0x00) 14459 { 14460 case 0x00: 14461 goto op_semantics_116; 14462 break; 14463 } 14464 break; 14465 case 0x61: 14466 GETBYTE (); 14467 switch (op[2] & 0x00) 14468 { 14469 case 0x00: 14470 goto op_semantics_116; 14471 break; 14472 } 14473 break; 14474 case 0x62: 14475 GETBYTE (); 14476 switch (op[2] & 0x00) 14477 { 14478 case 0x00: 14479 goto op_semantics_116; 14480 break; 14481 } 14482 break; 14483 case 0x63: 14484 GETBYTE (); 14485 switch (op[2] & 0x00) 14486 { 14487 case 0x00: 14488 goto op_semantics_116; 14489 break; 14490 } 14491 break; 14492 case 0x64: 14493 GETBYTE (); 14494 switch (op[2] & 0x00) 14495 { 14496 case 0x00: 14497 goto op_semantics_116; 14498 break; 14499 } 14500 break; 14501 case 0x65: 14502 GETBYTE (); 14503 switch (op[2] & 0x00) 14504 { 14505 case 0x00: 14506 goto op_semantics_116; 14507 break; 14508 } 14509 break; 14510 case 0x66: 14511 GETBYTE (); 14512 switch (op[2] & 0x00) 14513 { 14514 case 0x00: 14515 goto op_semantics_116; 14516 break; 14517 } 14518 break; 14519 case 0x67: 14520 GETBYTE (); 14521 switch (op[2] & 0x00) 14522 { 14523 case 0x00: 14524 goto op_semantics_116; 14525 break; 14526 } 14527 break; 14528 case 0x68: 14529 GETBYTE (); 14530 switch (op[2] & 0x00) 14531 { 14532 case 0x00: 14533 goto op_semantics_116; 14534 break; 14535 } 14536 break; 14537 case 0x69: 14538 GETBYTE (); 14539 switch (op[2] & 0x00) 14540 { 14541 case 0x00: 14542 goto op_semantics_116; 14543 break; 14544 } 14545 break; 14546 case 0x6a: 14547 GETBYTE (); 14548 switch (op[2] & 0x00) 14549 { 14550 case 0x00: 14551 goto op_semantics_116; 14552 break; 14553 } 14554 break; 14555 case 0x6b: 14556 GETBYTE (); 14557 switch (op[2] & 0x00) 14558 { 14559 case 0x00: 14560 goto op_semantics_116; 14561 break; 14562 } 14563 break; 14564 case 0x6c: 14565 GETBYTE (); 14566 switch (op[2] & 0x00) 14567 { 14568 case 0x00: 14569 goto op_semantics_116; 14570 break; 14571 } 14572 break; 14573 case 0x6d: 14574 GETBYTE (); 14575 switch (op[2] & 0x00) 14576 { 14577 case 0x00: 14578 goto op_semantics_116; 14579 break; 14580 } 14581 break; 14582 case 0x6e: 14583 GETBYTE (); 14584 switch (op[2] & 0x00) 14585 { 14586 case 0x00: 14587 goto op_semantics_116; 14588 break; 14589 } 14590 break; 14591 case 0x6f: 14592 GETBYTE (); 14593 switch (op[2] & 0x00) 14594 { 14595 case 0x00: 14596 goto op_semantics_116; 14597 break; 14598 } 14599 break; 14600 case 0xc0: 14601 GETBYTE (); 14602 switch (op[2] & 0x00) 14603 { 14604 case 0x00: 14605 op_semantics_117: 14606 { 14607 /** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */ 14608 #line 341 "rx-decode.opc" 14609 int sz AU = (op[1] >> 4) & 0x03; 14610 #line 341 "rx-decode.opc" 14611 int isrc AU = op[1] & 0x0f; 14612 #line 341 "rx-decode.opc" 14613 int bsrc AU = (op[2] >> 4) & 0x0f; 14614 #line 341 "rx-decode.opc" 14615 int rdst AU = op[2] & 0x0f; 14616 if (trace) 14617 { 14618 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 14619 "/** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */", 14620 op[0], op[1], op[2]); 14621 printf (" sz = 0x%x,", sz); 14622 printf (" isrc = 0x%x,", isrc); 14623 printf (" bsrc = 0x%x,", bsrc); 14624 printf (" rdst = 0x%x\n", rdst); 14625 } 14626 SYNTAX("movu%s [%1, %2], %0"); 14627 #line 341 "rx-decode.opc" 14628 ID(movbi); uBW(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____; 14629 14630 } 14631 break; 14632 } 14633 break; 14634 case 0xc1: 14635 GETBYTE (); 14636 switch (op[2] & 0x00) 14637 { 14638 case 0x00: 14639 goto op_semantics_117; 14640 break; 14641 } 14642 break; 14643 case 0xc2: 14644 GETBYTE (); 14645 switch (op[2] & 0x00) 14646 { 14647 case 0x00: 14648 goto op_semantics_117; 14649 break; 14650 } 14651 break; 14652 case 0xc3: 14653 GETBYTE (); 14654 switch (op[2] & 0x00) 14655 { 14656 case 0x00: 14657 goto op_semantics_117; 14658 break; 14659 } 14660 break; 14661 case 0xc4: 14662 GETBYTE (); 14663 switch (op[2] & 0x00) 14664 { 14665 case 0x00: 14666 goto op_semantics_117; 14667 break; 14668 } 14669 break; 14670 case 0xc5: 14671 GETBYTE (); 14672 switch (op[2] & 0x00) 14673 { 14674 case 0x00: 14675 goto op_semantics_117; 14676 break; 14677 } 14678 break; 14679 case 0xc6: 14680 GETBYTE (); 14681 switch (op[2] & 0x00) 14682 { 14683 case 0x00: 14684 goto op_semantics_117; 14685 break; 14686 } 14687 break; 14688 case 0xc7: 14689 GETBYTE (); 14690 switch (op[2] & 0x00) 14691 { 14692 case 0x00: 14693 goto op_semantics_117; 14694 break; 14695 } 14696 break; 14697 case 0xc8: 14698 GETBYTE (); 14699 switch (op[2] & 0x00) 14700 { 14701 case 0x00: 14702 goto op_semantics_117; 14703 break; 14704 } 14705 break; 14706 case 0xc9: 14707 GETBYTE (); 14708 switch (op[2] & 0x00) 14709 { 14710 case 0x00: 14711 goto op_semantics_117; 14712 break; 14713 } 14714 break; 14715 case 0xca: 14716 GETBYTE (); 14717 switch (op[2] & 0x00) 14718 { 14719 case 0x00: 14720 goto op_semantics_117; 14721 break; 14722 } 14723 break; 14724 case 0xcb: 14725 GETBYTE (); 14726 switch (op[2] & 0x00) 14727 { 14728 case 0x00: 14729 goto op_semantics_117; 14730 break; 14731 } 14732 break; 14733 case 0xcc: 14734 GETBYTE (); 14735 switch (op[2] & 0x00) 14736 { 14737 case 0x00: 14738 goto op_semantics_117; 14739 break; 14740 } 14741 break; 14742 case 0xcd: 14743 GETBYTE (); 14744 switch (op[2] & 0x00) 14745 { 14746 case 0x00: 14747 goto op_semantics_117; 14748 break; 14749 } 14750 break; 14751 case 0xce: 14752 GETBYTE (); 14753 switch (op[2] & 0x00) 14754 { 14755 case 0x00: 14756 goto op_semantics_117; 14757 break; 14758 } 14759 break; 14760 case 0xcf: 14761 GETBYTE (); 14762 switch (op[2] & 0x00) 14763 { 14764 case 0x00: 14765 goto op_semantics_117; 14766 break; 14767 } 14768 break; 14769 case 0xd0: 14770 GETBYTE (); 14771 switch (op[2] & 0x00) 14772 { 14773 case 0x00: 14774 goto op_semantics_117; 14775 break; 14776 } 14777 break; 14778 case 0xd1: 14779 GETBYTE (); 14780 switch (op[2] & 0x00) 14781 { 14782 case 0x00: 14783 goto op_semantics_117; 14784 break; 14785 } 14786 break; 14787 case 0xd2: 14788 GETBYTE (); 14789 switch (op[2] & 0x00) 14790 { 14791 case 0x00: 14792 goto op_semantics_117; 14793 break; 14794 } 14795 break; 14796 case 0xd3: 14797 GETBYTE (); 14798 switch (op[2] & 0x00) 14799 { 14800 case 0x00: 14801 goto op_semantics_117; 14802 break; 14803 } 14804 break; 14805 case 0xd4: 14806 GETBYTE (); 14807 switch (op[2] & 0x00) 14808 { 14809 case 0x00: 14810 goto op_semantics_117; 14811 break; 14812 } 14813 break; 14814 case 0xd5: 14815 GETBYTE (); 14816 switch (op[2] & 0x00) 14817 { 14818 case 0x00: 14819 goto op_semantics_117; 14820 break; 14821 } 14822 break; 14823 case 0xd6: 14824 GETBYTE (); 14825 switch (op[2] & 0x00) 14826 { 14827 case 0x00: 14828 goto op_semantics_117; 14829 break; 14830 } 14831 break; 14832 case 0xd7: 14833 GETBYTE (); 14834 switch (op[2] & 0x00) 14835 { 14836 case 0x00: 14837 goto op_semantics_117; 14838 break; 14839 } 14840 break; 14841 case 0xd8: 14842 GETBYTE (); 14843 switch (op[2] & 0x00) 14844 { 14845 case 0x00: 14846 goto op_semantics_117; 14847 break; 14848 } 14849 break; 14850 case 0xd9: 14851 GETBYTE (); 14852 switch (op[2] & 0x00) 14853 { 14854 case 0x00: 14855 goto op_semantics_117; 14856 break; 14857 } 14858 break; 14859 case 0xda: 14860 GETBYTE (); 14861 switch (op[2] & 0x00) 14862 { 14863 case 0x00: 14864 goto op_semantics_117; 14865 break; 14866 } 14867 break; 14868 case 0xdb: 14869 GETBYTE (); 14870 switch (op[2] & 0x00) 14871 { 14872 case 0x00: 14873 goto op_semantics_117; 14874 break; 14875 } 14876 break; 14877 case 0xdc: 14878 GETBYTE (); 14879 switch (op[2] & 0x00) 14880 { 14881 case 0x00: 14882 goto op_semantics_117; 14883 break; 14884 } 14885 break; 14886 case 0xdd: 14887 GETBYTE (); 14888 switch (op[2] & 0x00) 14889 { 14890 case 0x00: 14891 goto op_semantics_117; 14892 break; 14893 } 14894 break; 14895 case 0xde: 14896 GETBYTE (); 14897 switch (op[2] & 0x00) 14898 { 14899 case 0x00: 14900 goto op_semantics_117; 14901 break; 14902 } 14903 break; 14904 case 0xdf: 14905 GETBYTE (); 14906 switch (op[2] & 0x00) 14907 { 14908 case 0x00: 14909 goto op_semantics_117; 14910 break; 14911 } 14912 break; 14913 case 0xe0: 14914 GETBYTE (); 14915 switch (op[2] & 0x00) 14916 { 14917 case 0x00: 14918 goto op_semantics_117; 14919 break; 14920 } 14921 break; 14922 case 0xe1: 14923 GETBYTE (); 14924 switch (op[2] & 0x00) 14925 { 14926 case 0x00: 14927 goto op_semantics_117; 14928 break; 14929 } 14930 break; 14931 case 0xe2: 14932 GETBYTE (); 14933 switch (op[2] & 0x00) 14934 { 14935 case 0x00: 14936 goto op_semantics_117; 14937 break; 14938 } 14939 break; 14940 case 0xe3: 14941 GETBYTE (); 14942 switch (op[2] & 0x00) 14943 { 14944 case 0x00: 14945 goto op_semantics_117; 14946 break; 14947 } 14948 break; 14949 case 0xe4: 14950 GETBYTE (); 14951 switch (op[2] & 0x00) 14952 { 14953 case 0x00: 14954 goto op_semantics_117; 14955 break; 14956 } 14957 break; 14958 case 0xe5: 14959 GETBYTE (); 14960 switch (op[2] & 0x00) 14961 { 14962 case 0x00: 14963 goto op_semantics_117; 14964 break; 14965 } 14966 break; 14967 case 0xe6: 14968 GETBYTE (); 14969 switch (op[2] & 0x00) 14970 { 14971 case 0x00: 14972 goto op_semantics_117; 14973 break; 14974 } 14975 break; 14976 case 0xe7: 14977 GETBYTE (); 14978 switch (op[2] & 0x00) 14979 { 14980 case 0x00: 14981 goto op_semantics_117; 14982 break; 14983 } 14984 break; 14985 case 0xe8: 14986 GETBYTE (); 14987 switch (op[2] & 0x00) 14988 { 14989 case 0x00: 14990 goto op_semantics_117; 14991 break; 14992 } 14993 break; 14994 case 0xe9: 14995 GETBYTE (); 14996 switch (op[2] & 0x00) 14997 { 14998 case 0x00: 14999 goto op_semantics_117; 15000 break; 15001 } 15002 break; 15003 case 0xea: 15004 GETBYTE (); 15005 switch (op[2] & 0x00) 15006 { 15007 case 0x00: 15008 goto op_semantics_117; 15009 break; 15010 } 15011 break; 15012 case 0xeb: 15013 GETBYTE (); 15014 switch (op[2] & 0x00) 15015 { 15016 case 0x00: 15017 goto op_semantics_117; 15018 break; 15019 } 15020 break; 15021 case 0xec: 15022 GETBYTE (); 15023 switch (op[2] & 0x00) 15024 { 15025 case 0x00: 15026 goto op_semantics_117; 15027 break; 15028 } 15029 break; 15030 case 0xed: 15031 GETBYTE (); 15032 switch (op[2] & 0x00) 15033 { 15034 case 0x00: 15035 goto op_semantics_117; 15036 break; 15037 } 15038 break; 15039 case 0xee: 15040 GETBYTE (); 15041 switch (op[2] & 0x00) 15042 { 15043 case 0x00: 15044 goto op_semantics_117; 15045 break; 15046 } 15047 break; 15048 case 0xef: 15049 GETBYTE (); 15050 switch (op[2] & 0x00) 15051 { 15052 case 0x00: 15053 goto op_semantics_117; 15054 break; 15055 } 15056 break; 15057 default: UNSUPPORTED(); break; 15058 } 15059 break; 15060 case 0xff: 15061 GETBYTE (); 15062 switch (op[1] & 0xff) 15063 { 15064 case 0x00: 15065 GETBYTE (); 15066 switch (op[2] & 0x00) 15067 { 15068 case 0x00: 15069 op_semantics_118: 15070 { 15071 /** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */ 15072 #line 545 "rx-decode.opc" 15073 int rdst AU = op[1] & 0x0f; 15074 #line 545 "rx-decode.opc" 15075 int srca AU = (op[2] >> 4) & 0x0f; 15076 #line 545 "rx-decode.opc" 15077 int srcb AU = op[2] & 0x0f; 15078 if (trace) 15079 { 15080 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 15081 "/** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */", 15082 op[0], op[1], op[2]); 15083 printf (" rdst = 0x%x,", rdst); 15084 printf (" srca = 0x%x,", srca); 15085 printf (" srcb = 0x%x\n", srcb); 15086 } 15087 SYNTAX("sub %2, %1, %0"); 15088 #line 545 "rx-decode.opc" 15089 ID(sub); DR(rdst); SR(srcb); S2R(srca); F_OSZC; 15090 15091 /*----------------------------------------------------------------------*/ 15092 /* SBB */ 15093 15094 } 15095 break; 15096 } 15097 break; 15098 case 0x01: 15099 GETBYTE (); 15100 switch (op[2] & 0x00) 15101 { 15102 case 0x00: 15103 goto op_semantics_118; 15104 break; 15105 } 15106 break; 15107 case 0x02: 15108 GETBYTE (); 15109 switch (op[2] & 0x00) 15110 { 15111 case 0x00: 15112 goto op_semantics_118; 15113 break; 15114 } 15115 break; 15116 case 0x03: 15117 GETBYTE (); 15118 switch (op[2] & 0x00) 15119 { 15120 case 0x00: 15121 goto op_semantics_118; 15122 break; 15123 } 15124 break; 15125 case 0x04: 15126 GETBYTE (); 15127 switch (op[2] & 0x00) 15128 { 15129 case 0x00: 15130 goto op_semantics_118; 15131 break; 15132 } 15133 break; 15134 case 0x05: 15135 GETBYTE (); 15136 switch (op[2] & 0x00) 15137 { 15138 case 0x00: 15139 goto op_semantics_118; 15140 break; 15141 } 15142 break; 15143 case 0x06: 15144 GETBYTE (); 15145 switch (op[2] & 0x00) 15146 { 15147 case 0x00: 15148 goto op_semantics_118; 15149 break; 15150 } 15151 break; 15152 case 0x07: 15153 GETBYTE (); 15154 switch (op[2] & 0x00) 15155 { 15156 case 0x00: 15157 goto op_semantics_118; 15158 break; 15159 } 15160 break; 15161 case 0x08: 15162 GETBYTE (); 15163 switch (op[2] & 0x00) 15164 { 15165 case 0x00: 15166 goto op_semantics_118; 15167 break; 15168 } 15169 break; 15170 case 0x09: 15171 GETBYTE (); 15172 switch (op[2] & 0x00) 15173 { 15174 case 0x00: 15175 goto op_semantics_118; 15176 break; 15177 } 15178 break; 15179 case 0x0a: 15180 GETBYTE (); 15181 switch (op[2] & 0x00) 15182 { 15183 case 0x00: 15184 goto op_semantics_118; 15185 break; 15186 } 15187 break; 15188 case 0x0b: 15189 GETBYTE (); 15190 switch (op[2] & 0x00) 15191 { 15192 case 0x00: 15193 goto op_semantics_118; 15194 break; 15195 } 15196 break; 15197 case 0x0c: 15198 GETBYTE (); 15199 switch (op[2] & 0x00) 15200 { 15201 case 0x00: 15202 goto op_semantics_118; 15203 break; 15204 } 15205 break; 15206 case 0x0d: 15207 GETBYTE (); 15208 switch (op[2] & 0x00) 15209 { 15210 case 0x00: 15211 goto op_semantics_118; 15212 break; 15213 } 15214 break; 15215 case 0x0e: 15216 GETBYTE (); 15217 switch (op[2] & 0x00) 15218 { 15219 case 0x00: 15220 goto op_semantics_118; 15221 break; 15222 } 15223 break; 15224 case 0x0f: 15225 GETBYTE (); 15226 switch (op[2] & 0x00) 15227 { 15228 case 0x00: 15229 goto op_semantics_118; 15230 break; 15231 } 15232 break; 15233 case 0x20: 15234 GETBYTE (); 15235 switch (op[2] & 0x00) 15236 { 15237 case 0x00: 15238 op_semantics_119: 15239 { 15240 /** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */ 15241 #line 512 "rx-decode.opc" 15242 int rdst AU = op[1] & 0x0f; 15243 #line 512 "rx-decode.opc" 15244 int srca AU = (op[2] >> 4) & 0x0f; 15245 #line 512 "rx-decode.opc" 15246 int srcb AU = op[2] & 0x0f; 15247 if (trace) 15248 { 15249 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 15250 "/** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */", 15251 op[0], op[1], op[2]); 15252 printf (" rdst = 0x%x,", rdst); 15253 printf (" srca = 0x%x,", srca); 15254 printf (" srcb = 0x%x\n", srcb); 15255 } 15256 SYNTAX("add %2, %1, %0"); 15257 #line 512 "rx-decode.opc" 15258 ID(add); DR(rdst); SR(srcb); S2R(srca); F_OSZC; 15259 15260 /*----------------------------------------------------------------------*/ 15261 /* CMP */ 15262 15263 } 15264 break; 15265 } 15266 break; 15267 case 0x21: 15268 GETBYTE (); 15269 switch (op[2] & 0x00) 15270 { 15271 case 0x00: 15272 goto op_semantics_119; 15273 break; 15274 } 15275 break; 15276 case 0x22: 15277 GETBYTE (); 15278 switch (op[2] & 0x00) 15279 { 15280 case 0x00: 15281 goto op_semantics_119; 15282 break; 15283 } 15284 break; 15285 case 0x23: 15286 GETBYTE (); 15287 switch (op[2] & 0x00) 15288 { 15289 case 0x00: 15290 goto op_semantics_119; 15291 break; 15292 } 15293 break; 15294 case 0x24: 15295 GETBYTE (); 15296 switch (op[2] & 0x00) 15297 { 15298 case 0x00: 15299 goto op_semantics_119; 15300 break; 15301 } 15302 break; 15303 case 0x25: 15304 GETBYTE (); 15305 switch (op[2] & 0x00) 15306 { 15307 case 0x00: 15308 goto op_semantics_119; 15309 break; 15310 } 15311 break; 15312 case 0x26: 15313 GETBYTE (); 15314 switch (op[2] & 0x00) 15315 { 15316 case 0x00: 15317 goto op_semantics_119; 15318 break; 15319 } 15320 break; 15321 case 0x27: 15322 GETBYTE (); 15323 switch (op[2] & 0x00) 15324 { 15325 case 0x00: 15326 goto op_semantics_119; 15327 break; 15328 } 15329 break; 15330 case 0x28: 15331 GETBYTE (); 15332 switch (op[2] & 0x00) 15333 { 15334 case 0x00: 15335 goto op_semantics_119; 15336 break; 15337 } 15338 break; 15339 case 0x29: 15340 GETBYTE (); 15341 switch (op[2] & 0x00) 15342 { 15343 case 0x00: 15344 goto op_semantics_119; 15345 break; 15346 } 15347 break; 15348 case 0x2a: 15349 GETBYTE (); 15350 switch (op[2] & 0x00) 15351 { 15352 case 0x00: 15353 goto op_semantics_119; 15354 break; 15355 } 15356 break; 15357 case 0x2b: 15358 GETBYTE (); 15359 switch (op[2] & 0x00) 15360 { 15361 case 0x00: 15362 goto op_semantics_119; 15363 break; 15364 } 15365 break; 15366 case 0x2c: 15367 GETBYTE (); 15368 switch (op[2] & 0x00) 15369 { 15370 case 0x00: 15371 goto op_semantics_119; 15372 break; 15373 } 15374 break; 15375 case 0x2d: 15376 GETBYTE (); 15377 switch (op[2] & 0x00) 15378 { 15379 case 0x00: 15380 goto op_semantics_119; 15381 break; 15382 } 15383 break; 15384 case 0x2e: 15385 GETBYTE (); 15386 switch (op[2] & 0x00) 15387 { 15388 case 0x00: 15389 goto op_semantics_119; 15390 break; 15391 } 15392 break; 15393 case 0x2f: 15394 GETBYTE (); 15395 switch (op[2] & 0x00) 15396 { 15397 case 0x00: 15398 goto op_semantics_119; 15399 break; 15400 } 15401 break; 15402 case 0x30: 15403 GETBYTE (); 15404 switch (op[2] & 0x00) 15405 { 15406 case 0x00: 15407 op_semantics_120: 15408 { 15409 /** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */ 15410 #line 652 "rx-decode.opc" 15411 int rdst AU = op[1] & 0x0f; 15412 #line 652 "rx-decode.opc" 15413 int srca AU = (op[2] >> 4) & 0x0f; 15414 #line 652 "rx-decode.opc" 15415 int srcb AU = op[2] & 0x0f; 15416 if (trace) 15417 { 15418 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 15419 "/** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */", 15420 op[0], op[1], op[2]); 15421 printf (" rdst = 0x%x,", rdst); 15422 printf (" srca = 0x%x,", srca); 15423 printf (" srcb = 0x%x\n", srcb); 15424 } 15425 SYNTAX("mul %2, %1, %0"); 15426 #line 652 "rx-decode.opc" 15427 ID(mul); DR(rdst); SR(srcb); S2R(srca); F_____; 15428 15429 /*----------------------------------------------------------------------*/ 15430 /* EMUL */ 15431 15432 } 15433 break; 15434 } 15435 break; 15436 case 0x31: 15437 GETBYTE (); 15438 switch (op[2] & 0x00) 15439 { 15440 case 0x00: 15441 goto op_semantics_120; 15442 break; 15443 } 15444 break; 15445 case 0x32: 15446 GETBYTE (); 15447 switch (op[2] & 0x00) 15448 { 15449 case 0x00: 15450 goto op_semantics_120; 15451 break; 15452 } 15453 break; 15454 case 0x33: 15455 GETBYTE (); 15456 switch (op[2] & 0x00) 15457 { 15458 case 0x00: 15459 goto op_semantics_120; 15460 break; 15461 } 15462 break; 15463 case 0x34: 15464 GETBYTE (); 15465 switch (op[2] & 0x00) 15466 { 15467 case 0x00: 15468 goto op_semantics_120; 15469 break; 15470 } 15471 break; 15472 case 0x35: 15473 GETBYTE (); 15474 switch (op[2] & 0x00) 15475 { 15476 case 0x00: 15477 goto op_semantics_120; 15478 break; 15479 } 15480 break; 15481 case 0x36: 15482 GETBYTE (); 15483 switch (op[2] & 0x00) 15484 { 15485 case 0x00: 15486 goto op_semantics_120; 15487 break; 15488 } 15489 break; 15490 case 0x37: 15491 GETBYTE (); 15492 switch (op[2] & 0x00) 15493 { 15494 case 0x00: 15495 goto op_semantics_120; 15496 break; 15497 } 15498 break; 15499 case 0x38: 15500 GETBYTE (); 15501 switch (op[2] & 0x00) 15502 { 15503 case 0x00: 15504 goto op_semantics_120; 15505 break; 15506 } 15507 break; 15508 case 0x39: 15509 GETBYTE (); 15510 switch (op[2] & 0x00) 15511 { 15512 case 0x00: 15513 goto op_semantics_120; 15514 break; 15515 } 15516 break; 15517 case 0x3a: 15518 GETBYTE (); 15519 switch (op[2] & 0x00) 15520 { 15521 case 0x00: 15522 goto op_semantics_120; 15523 break; 15524 } 15525 break; 15526 case 0x3b: 15527 GETBYTE (); 15528 switch (op[2] & 0x00) 15529 { 15530 case 0x00: 15531 goto op_semantics_120; 15532 break; 15533 } 15534 break; 15535 case 0x3c: 15536 GETBYTE (); 15537 switch (op[2] & 0x00) 15538 { 15539 case 0x00: 15540 goto op_semantics_120; 15541 break; 15542 } 15543 break; 15544 case 0x3d: 15545 GETBYTE (); 15546 switch (op[2] & 0x00) 15547 { 15548 case 0x00: 15549 goto op_semantics_120; 15550 break; 15551 } 15552 break; 15553 case 0x3e: 15554 GETBYTE (); 15555 switch (op[2] & 0x00) 15556 { 15557 case 0x00: 15558 goto op_semantics_120; 15559 break; 15560 } 15561 break; 15562 case 0x3f: 15563 GETBYTE (); 15564 switch (op[2] & 0x00) 15565 { 15566 case 0x00: 15567 goto op_semantics_120; 15568 break; 15569 } 15570 break; 15571 case 0x40: 15572 GETBYTE (); 15573 switch (op[2] & 0x00) 15574 { 15575 case 0x00: 15576 op_semantics_121: 15577 { 15578 /** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */ 15579 #line 422 "rx-decode.opc" 15580 int rdst AU = op[1] & 0x0f; 15581 #line 422 "rx-decode.opc" 15582 int srca AU = (op[2] >> 4) & 0x0f; 15583 #line 422 "rx-decode.opc" 15584 int srcb AU = op[2] & 0x0f; 15585 if (trace) 15586 { 15587 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 15588 "/** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */", 15589 op[0], op[1], op[2]); 15590 printf (" rdst = 0x%x,", rdst); 15591 printf (" srca = 0x%x,", srca); 15592 printf (" srcb = 0x%x\n", srcb); 15593 } 15594 SYNTAX("and %2, %1, %0"); 15595 #line 422 "rx-decode.opc" 15596 ID(and); DR(rdst); SR(srcb); S2R(srca); F__SZ_; 15597 15598 /*----------------------------------------------------------------------*/ 15599 /* OR */ 15600 15601 } 15602 break; 15603 } 15604 break; 15605 case 0x41: 15606 GETBYTE (); 15607 switch (op[2] & 0x00) 15608 { 15609 case 0x00: 15610 goto op_semantics_121; 15611 break; 15612 } 15613 break; 15614 case 0x42: 15615 GETBYTE (); 15616 switch (op[2] & 0x00) 15617 { 15618 case 0x00: 15619 goto op_semantics_121; 15620 break; 15621 } 15622 break; 15623 case 0x43: 15624 GETBYTE (); 15625 switch (op[2] & 0x00) 15626 { 15627 case 0x00: 15628 goto op_semantics_121; 15629 break; 15630 } 15631 break; 15632 case 0x44: 15633 GETBYTE (); 15634 switch (op[2] & 0x00) 15635 { 15636 case 0x00: 15637 goto op_semantics_121; 15638 break; 15639 } 15640 break; 15641 case 0x45: 15642 GETBYTE (); 15643 switch (op[2] & 0x00) 15644 { 15645 case 0x00: 15646 goto op_semantics_121; 15647 break; 15648 } 15649 break; 15650 case 0x46: 15651 GETBYTE (); 15652 switch (op[2] & 0x00) 15653 { 15654 case 0x00: 15655 goto op_semantics_121; 15656 break; 15657 } 15658 break; 15659 case 0x47: 15660 GETBYTE (); 15661 switch (op[2] & 0x00) 15662 { 15663 case 0x00: 15664 goto op_semantics_121; 15665 break; 15666 } 15667 break; 15668 case 0x48: 15669 GETBYTE (); 15670 switch (op[2] & 0x00) 15671 { 15672 case 0x00: 15673 goto op_semantics_121; 15674 break; 15675 } 15676 break; 15677 case 0x49: 15678 GETBYTE (); 15679 switch (op[2] & 0x00) 15680 { 15681 case 0x00: 15682 goto op_semantics_121; 15683 break; 15684 } 15685 break; 15686 case 0x4a: 15687 GETBYTE (); 15688 switch (op[2] & 0x00) 15689 { 15690 case 0x00: 15691 goto op_semantics_121; 15692 break; 15693 } 15694 break; 15695 case 0x4b: 15696 GETBYTE (); 15697 switch (op[2] & 0x00) 15698 { 15699 case 0x00: 15700 goto op_semantics_121; 15701 break; 15702 } 15703 break; 15704 case 0x4c: 15705 GETBYTE (); 15706 switch (op[2] & 0x00) 15707 { 15708 case 0x00: 15709 goto op_semantics_121; 15710 break; 15711 } 15712 break; 15713 case 0x4d: 15714 GETBYTE (); 15715 switch (op[2] & 0x00) 15716 { 15717 case 0x00: 15718 goto op_semantics_121; 15719 break; 15720 } 15721 break; 15722 case 0x4e: 15723 GETBYTE (); 15724 switch (op[2] & 0x00) 15725 { 15726 case 0x00: 15727 goto op_semantics_121; 15728 break; 15729 } 15730 break; 15731 case 0x4f: 15732 GETBYTE (); 15733 switch (op[2] & 0x00) 15734 { 15735 case 0x00: 15736 goto op_semantics_121; 15737 break; 15738 } 15739 break; 15740 case 0x50: 15741 GETBYTE (); 15742 switch (op[2] & 0x00) 15743 { 15744 case 0x00: 15745 op_semantics_122: 15746 { 15747 /** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */ 15748 #line 440 "rx-decode.opc" 15749 int rdst AU = op[1] & 0x0f; 15750 #line 440 "rx-decode.opc" 15751 int srca AU = (op[2] >> 4) & 0x0f; 15752 #line 440 "rx-decode.opc" 15753 int srcb AU = op[2] & 0x0f; 15754 if (trace) 15755 { 15756 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 15757 "/** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */", 15758 op[0], op[1], op[2]); 15759 printf (" rdst = 0x%x,", rdst); 15760 printf (" srca = 0x%x,", srca); 15761 printf (" srcb = 0x%x\n", srcb); 15762 } 15763 SYNTAX("or %2, %1, %0"); 15764 #line 440 "rx-decode.opc" 15765 ID(or); DR(rdst); SR(srcb); S2R(srca); F__SZ_; 15766 15767 /*----------------------------------------------------------------------*/ 15768 /* XOR */ 15769 15770 } 15771 break; 15772 } 15773 break; 15774 case 0x51: 15775 GETBYTE (); 15776 switch (op[2] & 0x00) 15777 { 15778 case 0x00: 15779 goto op_semantics_122; 15780 break; 15781 } 15782 break; 15783 case 0x52: 15784 GETBYTE (); 15785 switch (op[2] & 0x00) 15786 { 15787 case 0x00: 15788 goto op_semantics_122; 15789 break; 15790 } 15791 break; 15792 case 0x53: 15793 GETBYTE (); 15794 switch (op[2] & 0x00) 15795 { 15796 case 0x00: 15797 goto op_semantics_122; 15798 break; 15799 } 15800 break; 15801 case 0x54: 15802 GETBYTE (); 15803 switch (op[2] & 0x00) 15804 { 15805 case 0x00: 15806 goto op_semantics_122; 15807 break; 15808 } 15809 break; 15810 case 0x55: 15811 GETBYTE (); 15812 switch (op[2] & 0x00) 15813 { 15814 case 0x00: 15815 goto op_semantics_122; 15816 break; 15817 } 15818 break; 15819 case 0x56: 15820 GETBYTE (); 15821 switch (op[2] & 0x00) 15822 { 15823 case 0x00: 15824 goto op_semantics_122; 15825 break; 15826 } 15827 break; 15828 case 0x57: 15829 GETBYTE (); 15830 switch (op[2] & 0x00) 15831 { 15832 case 0x00: 15833 goto op_semantics_122; 15834 break; 15835 } 15836 break; 15837 case 0x58: 15838 GETBYTE (); 15839 switch (op[2] & 0x00) 15840 { 15841 case 0x00: 15842 goto op_semantics_122; 15843 break; 15844 } 15845 break; 15846 case 0x59: 15847 GETBYTE (); 15848 switch (op[2] & 0x00) 15849 { 15850 case 0x00: 15851 goto op_semantics_122; 15852 break; 15853 } 15854 break; 15855 case 0x5a: 15856 GETBYTE (); 15857 switch (op[2] & 0x00) 15858 { 15859 case 0x00: 15860 goto op_semantics_122; 15861 break; 15862 } 15863 break; 15864 case 0x5b: 15865 GETBYTE (); 15866 switch (op[2] & 0x00) 15867 { 15868 case 0x00: 15869 goto op_semantics_122; 15870 break; 15871 } 15872 break; 15873 case 0x5c: 15874 GETBYTE (); 15875 switch (op[2] & 0x00) 15876 { 15877 case 0x00: 15878 goto op_semantics_122; 15879 break; 15880 } 15881 break; 15882 case 0x5d: 15883 GETBYTE (); 15884 switch (op[2] & 0x00) 15885 { 15886 case 0x00: 15887 goto op_semantics_122; 15888 break; 15889 } 15890 break; 15891 case 0x5e: 15892 GETBYTE (); 15893 switch (op[2] & 0x00) 15894 { 15895 case 0x00: 15896 goto op_semantics_122; 15897 break; 15898 } 15899 break; 15900 case 0x5f: 15901 GETBYTE (); 15902 switch (op[2] & 0x00) 15903 { 15904 case 0x00: 15905 goto op_semantics_122; 15906 break; 15907 } 15908 break; 15909 case 0x80: 15910 GETBYTE (); 15911 switch (op[2] & 0x00) 15912 { 15913 case 0x00: 15914 op_semantics_123: 15915 { 15916 /** 1111 1111 1000 rdst srca srcb fsub %2, %1, %0 */ 15917 #line 1100 "rx-decode.opc" 15918 int rdst AU = op[1] & 0x0f; 15919 #line 1100 "rx-decode.opc" 15920 int srca AU = (op[2] >> 4) & 0x0f; 15921 #line 1100 "rx-decode.opc" 15922 int srcb AU = op[2] & 0x0f; 15923 if (trace) 15924 { 15925 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 15926 "/** 1111 1111 1000 rdst srca srcb fsub %2, %1, %0 */", 15927 op[0], op[1], op[2]); 15928 printf (" rdst = 0x%x,", rdst); 15929 printf (" srca = 0x%x,", srca); 15930 printf (" srcb = 0x%x\n", srcb); 15931 } 15932 SYNTAX("fsub %2, %1, %0"); 15933 #line 1100 "rx-decode.opc" 15934 ID(fsub); DR(rdst); SR(srcb); S2R(srca); F__SZ_; 15935 15936 } 15937 break; 15938 } 15939 break; 15940 case 0x81: 15941 GETBYTE (); 15942 switch (op[2] & 0x00) 15943 { 15944 case 0x00: 15945 goto op_semantics_123; 15946 break; 15947 } 15948 break; 15949 case 0x82: 15950 GETBYTE (); 15951 switch (op[2] & 0x00) 15952 { 15953 case 0x00: 15954 goto op_semantics_123; 15955 break; 15956 } 15957 break; 15958 case 0x83: 15959 GETBYTE (); 15960 switch (op[2] & 0x00) 15961 { 15962 case 0x00: 15963 goto op_semantics_123; 15964 break; 15965 } 15966 break; 15967 case 0x84: 15968 GETBYTE (); 15969 switch (op[2] & 0x00) 15970 { 15971 case 0x00: 15972 goto op_semantics_123; 15973 break; 15974 } 15975 break; 15976 case 0x85: 15977 GETBYTE (); 15978 switch (op[2] & 0x00) 15979 { 15980 case 0x00: 15981 goto op_semantics_123; 15982 break; 15983 } 15984 break; 15985 case 0x86: 15986 GETBYTE (); 15987 switch (op[2] & 0x00) 15988 { 15989 case 0x00: 15990 goto op_semantics_123; 15991 break; 15992 } 15993 break; 15994 case 0x87: 15995 GETBYTE (); 15996 switch (op[2] & 0x00) 15997 { 15998 case 0x00: 15999 goto op_semantics_123; 16000 break; 16001 } 16002 break; 16003 case 0x88: 16004 GETBYTE (); 16005 switch (op[2] & 0x00) 16006 { 16007 case 0x00: 16008 goto op_semantics_123; 16009 break; 16010 } 16011 break; 16012 case 0x89: 16013 GETBYTE (); 16014 switch (op[2] & 0x00) 16015 { 16016 case 0x00: 16017 goto op_semantics_123; 16018 break; 16019 } 16020 break; 16021 case 0x8a: 16022 GETBYTE (); 16023 switch (op[2] & 0x00) 16024 { 16025 case 0x00: 16026 goto op_semantics_123; 16027 break; 16028 } 16029 break; 16030 case 0x8b: 16031 GETBYTE (); 16032 switch (op[2] & 0x00) 16033 { 16034 case 0x00: 16035 goto op_semantics_123; 16036 break; 16037 } 16038 break; 16039 case 0x8c: 16040 GETBYTE (); 16041 switch (op[2] & 0x00) 16042 { 16043 case 0x00: 16044 goto op_semantics_123; 16045 break; 16046 } 16047 break; 16048 case 0x8d: 16049 GETBYTE (); 16050 switch (op[2] & 0x00) 16051 { 16052 case 0x00: 16053 goto op_semantics_123; 16054 break; 16055 } 16056 break; 16057 case 0x8e: 16058 GETBYTE (); 16059 switch (op[2] & 0x00) 16060 { 16061 case 0x00: 16062 goto op_semantics_123; 16063 break; 16064 } 16065 break; 16066 case 0x8f: 16067 GETBYTE (); 16068 switch (op[2] & 0x00) 16069 { 16070 case 0x00: 16071 goto op_semantics_123; 16072 break; 16073 } 16074 break; 16075 case 0xa0: 16076 GETBYTE (); 16077 switch (op[2] & 0x00) 16078 { 16079 case 0x00: 16080 op_semantics_124: 16081 { 16082 /** 1111 1111 1010 rdst srca srcb fadd %2, %1, %0 */ 16083 #line 1097 "rx-decode.opc" 16084 int rdst AU = op[1] & 0x0f; 16085 #line 1097 "rx-decode.opc" 16086 int srca AU = (op[2] >> 4) & 0x0f; 16087 #line 1097 "rx-decode.opc" 16088 int srcb AU = op[2] & 0x0f; 16089 if (trace) 16090 { 16091 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 16092 "/** 1111 1111 1010 rdst srca srcb fadd %2, %1, %0 */", 16093 op[0], op[1], op[2]); 16094 printf (" rdst = 0x%x,", rdst); 16095 printf (" srca = 0x%x,", srca); 16096 printf (" srcb = 0x%x\n", srcb); 16097 } 16098 SYNTAX("fadd %2, %1, %0"); 16099 #line 1097 "rx-decode.opc" 16100 ID(fadd); DR(rdst); SR(srcb); S2R(srca); F__SZ_; 16101 16102 } 16103 break; 16104 } 16105 break; 16106 case 0xa1: 16107 GETBYTE (); 16108 switch (op[2] & 0x00) 16109 { 16110 case 0x00: 16111 goto op_semantics_124; 16112 break; 16113 } 16114 break; 16115 case 0xa2: 16116 GETBYTE (); 16117 switch (op[2] & 0x00) 16118 { 16119 case 0x00: 16120 goto op_semantics_124; 16121 break; 16122 } 16123 break; 16124 case 0xa3: 16125 GETBYTE (); 16126 switch (op[2] & 0x00) 16127 { 16128 case 0x00: 16129 goto op_semantics_124; 16130 break; 16131 } 16132 break; 16133 case 0xa4: 16134 GETBYTE (); 16135 switch (op[2] & 0x00) 16136 { 16137 case 0x00: 16138 goto op_semantics_124; 16139 break; 16140 } 16141 break; 16142 case 0xa5: 16143 GETBYTE (); 16144 switch (op[2] & 0x00) 16145 { 16146 case 0x00: 16147 goto op_semantics_124; 16148 break; 16149 } 16150 break; 16151 case 0xa6: 16152 GETBYTE (); 16153 switch (op[2] & 0x00) 16154 { 16155 case 0x00: 16156 goto op_semantics_124; 16157 break; 16158 } 16159 break; 16160 case 0xa7: 16161 GETBYTE (); 16162 switch (op[2] & 0x00) 16163 { 16164 case 0x00: 16165 goto op_semantics_124; 16166 break; 16167 } 16168 break; 16169 case 0xa8: 16170 GETBYTE (); 16171 switch (op[2] & 0x00) 16172 { 16173 case 0x00: 16174 goto op_semantics_124; 16175 break; 16176 } 16177 break; 16178 case 0xa9: 16179 GETBYTE (); 16180 switch (op[2] & 0x00) 16181 { 16182 case 0x00: 16183 goto op_semantics_124; 16184 break; 16185 } 16186 break; 16187 case 0xaa: 16188 GETBYTE (); 16189 switch (op[2] & 0x00) 16190 { 16191 case 0x00: 16192 goto op_semantics_124; 16193 break; 16194 } 16195 break; 16196 case 0xab: 16197 GETBYTE (); 16198 switch (op[2] & 0x00) 16199 { 16200 case 0x00: 16201 goto op_semantics_124; 16202 break; 16203 } 16204 break; 16205 case 0xac: 16206 GETBYTE (); 16207 switch (op[2] & 0x00) 16208 { 16209 case 0x00: 16210 goto op_semantics_124; 16211 break; 16212 } 16213 break; 16214 case 0xad: 16215 GETBYTE (); 16216 switch (op[2] & 0x00) 16217 { 16218 case 0x00: 16219 goto op_semantics_124; 16220 break; 16221 } 16222 break; 16223 case 0xae: 16224 GETBYTE (); 16225 switch (op[2] & 0x00) 16226 { 16227 case 0x00: 16228 goto op_semantics_124; 16229 break; 16230 } 16231 break; 16232 case 0xaf: 16233 GETBYTE (); 16234 switch (op[2] & 0x00) 16235 { 16236 case 0x00: 16237 goto op_semantics_124; 16238 break; 16239 } 16240 break; 16241 case 0xb0: 16242 GETBYTE (); 16243 switch (op[2] & 0x00) 16244 { 16245 case 0x00: 16246 op_semantics_125: 16247 { 16248 /** 1111 1111 1011 rdst srca srcb fmul %2, %1, %0 */ 16249 #line 1103 "rx-decode.opc" 16250 int rdst AU = op[1] & 0x0f; 16251 #line 1103 "rx-decode.opc" 16252 int srca AU = (op[2] >> 4) & 0x0f; 16253 #line 1103 "rx-decode.opc" 16254 int srcb AU = op[2] & 0x0f; 16255 if (trace) 16256 { 16257 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 16258 "/** 1111 1111 1011 rdst srca srcb fmul %2, %1, %0 */", 16259 op[0], op[1], op[2]); 16260 printf (" rdst = 0x%x,", rdst); 16261 printf (" srca = 0x%x,", srca); 16262 printf (" srcb = 0x%x\n", srcb); 16263 } 16264 SYNTAX("fmul %2, %1, %0"); 16265 #line 1103 "rx-decode.opc" 16266 ID(fmul); DR(rdst); SR(srcb); S2R(srca); F__SZ_; 16267 16268 } 16269 break; 16270 } 16271 break; 16272 case 0xb1: 16273 GETBYTE (); 16274 switch (op[2] & 0x00) 16275 { 16276 case 0x00: 16277 goto op_semantics_125; 16278 break; 16279 } 16280 break; 16281 case 0xb2: 16282 GETBYTE (); 16283 switch (op[2] & 0x00) 16284 { 16285 case 0x00: 16286 goto op_semantics_125; 16287 break; 16288 } 16289 break; 16290 case 0xb3: 16291 GETBYTE (); 16292 switch (op[2] & 0x00) 16293 { 16294 case 0x00: 16295 goto op_semantics_125; 16296 break; 16297 } 16298 break; 16299 case 0xb4: 16300 GETBYTE (); 16301 switch (op[2] & 0x00) 16302 { 16303 case 0x00: 16304 goto op_semantics_125; 16305 break; 16306 } 16307 break; 16308 case 0xb5: 16309 GETBYTE (); 16310 switch (op[2] & 0x00) 16311 { 16312 case 0x00: 16313 goto op_semantics_125; 16314 break; 16315 } 16316 break; 16317 case 0xb6: 16318 GETBYTE (); 16319 switch (op[2] & 0x00) 16320 { 16321 case 0x00: 16322 goto op_semantics_125; 16323 break; 16324 } 16325 break; 16326 case 0xb7: 16327 GETBYTE (); 16328 switch (op[2] & 0x00) 16329 { 16330 case 0x00: 16331 goto op_semantics_125; 16332 break; 16333 } 16334 break; 16335 case 0xb8: 16336 GETBYTE (); 16337 switch (op[2] & 0x00) 16338 { 16339 case 0x00: 16340 goto op_semantics_125; 16341 break; 16342 } 16343 break; 16344 case 0xb9: 16345 GETBYTE (); 16346 switch (op[2] & 0x00) 16347 { 16348 case 0x00: 16349 goto op_semantics_125; 16350 break; 16351 } 16352 break; 16353 case 0xba: 16354 GETBYTE (); 16355 switch (op[2] & 0x00) 16356 { 16357 case 0x00: 16358 goto op_semantics_125; 16359 break; 16360 } 16361 break; 16362 case 0xbb: 16363 GETBYTE (); 16364 switch (op[2] & 0x00) 16365 { 16366 case 0x00: 16367 goto op_semantics_125; 16368 break; 16369 } 16370 break; 16371 case 0xbc: 16372 GETBYTE (); 16373 switch (op[2] & 0x00) 16374 { 16375 case 0x00: 16376 goto op_semantics_125; 16377 break; 16378 } 16379 break; 16380 case 0xbd: 16381 GETBYTE (); 16382 switch (op[2] & 0x00) 16383 { 16384 case 0x00: 16385 goto op_semantics_125; 16386 break; 16387 } 16388 break; 16389 case 0xbe: 16390 GETBYTE (); 16391 switch (op[2] & 0x00) 16392 { 16393 case 0x00: 16394 goto op_semantics_125; 16395 break; 16396 } 16397 break; 16398 case 0xbf: 16399 GETBYTE (); 16400 switch (op[2] & 0x00) 16401 { 16402 case 0x00: 16403 goto op_semantics_125; 16404 break; 16405 } 16406 break; 16407 default: UNSUPPORTED(); break; 16408 } 16409 break; 16410 default: UNSUPPORTED(); break; 16411 } 16412 #line 1118 "rx-decode.opc" 16413 16414 return rx->n_bytes; 16415 } 16416
