opcodes/rx-decode.c

   1 #line 2 "/work/sources/gcc/current/opcodes/rx-decode.opc"
   2 /* -*- c -*- */
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <string.h>
   6
   7 #include "config.h"
   8 #include "ansidecl.h"
   9 #include "opcode/rx.h"
  10
  11 #define RX_OPCODE_BIG_ENDIAN 0
  12
  13 typedef struct
  14 {
  15   RX_Opcode_Decoded * rx;
  16   int (* getbyte)(void *);
  17   void * ptr;
  18   unsigned char * op;
  19 } LocalData;
  20
  21 static int trace = 0;
  22
  23 #define BSIZE 0
  24 #define WSIZE 1
  25 #define LSIZE 2
  26
  27 /* These are for when the upper bits are "don't care" or "undefined".  */
  28 static int bwl[] =
  29 {
  30   RX_Byte,
  31   RX_Word,
  32   RX_Long
  33 };
  34
  35 static int sbwl[] =
  36 {
  37   RX_SByte,
  38   RX_SWord,
  39   RX_Long
  40 };
  41
  42 static int ubwl[] =
  43 {
  44   RX_UByte,
  45   RX_UWord,
  46   RX_Long
  47 };
  48
  49 static int memex[] =
  50 {
  51   RX_SByte,
  52   RX_SWord,
  53   RX_Long,
  54   RX_UWord
  55 };
  56
  57 #define ID(x) rx->id = RXO_##x
  58 #define OP(n,t,r,a) (rx->op[n].type = t, \
  59                      rx->op[n].reg = r,      \
  60                      rx->op[n].addend = a )
  61 #define OPs(n,t,r,a,s) (OP (n,t,r,a), \
  62                         rx->op[n].size = s )
  63
  64 /* This is for the BWL and BW bitfields.  */
  65 static int SCALE[] = { 1, 2, 4 };
  66 /* This is for the prefix size enum.  */
  67 static int PSCALE[] = { 4, 1, 1, 1, 2, 2, 2, 3, 4 };
  68
  69 static int flagmap[] = {0, 1, 2, 3, 0, 0, 0, 0,
  70                        16, 17, 0, 0, 0, 0, 0, 0 };
  71
  72 static int dsp3map[] = { 8, 9, 10, 3, 4, 5, 6, 7 };
  73
  74 /*
  75  *C     a constant (immediate) c
  76  *R     A register
  77  *I     Register indirect, no offset
  78  *Is    Register indirect, with offset
  79  *D     standard displacement: type (r,[r],dsp8,dsp16 code), register, BWL code
  80  *P     standard displacement: type (r,[r]), reg, assumes UByte
  81  *Pm    memex displacement: type (r,[r]), reg, memex code
  82  *cc    condition code.  */
  83
  84 #define DC(c)       OP (0, RX_Operand_Immediate, 0, c)
  85 #define DR(r)       OP (0, RX_Operand_Register,  r, 0)
  86 #define DI(r,a)     OP (0, RX_Operand_Indirect,  r, a)
  87 #define DIs(r,a,s)  OP (0, RX_Operand_Indirect,  r, (a) * SCALE[s])
  88 #define DD(t,r,s)   rx_disp (0, t, r, bwl[s], ld);
  89 #define DF(r)       OP (0, RX_Operand_Flag,  flagmap[r], 0)
  90
  91 #define SC(i)       OP (1, RX_Operand_Immediate, 0, i)
  92 #define SR(r)       OP (1, RX_Operand_Register,  r, 0)
  93 #define SI(r,a)     OP (1, RX_Operand_Indirect,  r, a)
  94 #define SIs(r,a,s)  OP (1, RX_Operand_Indirect,  r, (a) * SCALE[s])
  95 #define SD(t,r,s)   rx_disp (1, t, r, bwl[s], ld);
  96 #define SP(t,r)     rx_disp (1, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 1);
  97 #define SPm(t,r,m)  rx_disp (1, t, r, memex[m], ld); rx->op[1].size = memex[m];
  98 #define Scc(cc)     OP (1, RX_Operand_Condition,  cc, 0)
  99
 100 #define S2C(i)      OP (2, RX_Operand_Immediate, 0, i)
 101 #define S2R(r)      OP (2, RX_Operand_Register,  r, 0)
 102 #define S2I(r,a)    OP (2, RX_Operand_Indirect,  r, a)
 103 #define S2Is(r,a,s) OP (2, RX_Operand_Indirect,  r, (a) * SCALE[s])
 104 #define S2D(t,r,s)  rx_disp (2, t, r, bwl[s], ld);
 105 #define S2P(t,r)    rx_disp (2, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 2);
 106 #define S2Pm(t,r,m) rx_disp (2, t, r, memex[m], ld); rx->op[2].size = memex[m];
 107 #define S2cc(cc)    OP (2, RX_Operand_Condition,  cc, 0)
 108
 109 #define BWL(sz)     rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = bwl[sz]
 110 #define sBWL(sz)    rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = sbwl[sz]
 111 #define uBWL(sz)    rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = ubwl[sz]
 112 #define P(t, n)     rx->op[n].size = (t!=3) ? RX_UByte : RX_Long;
 113
 114 #define F(f) store_flags(rx, f)
 115
 116 #define AU ATTRIBUTE_UNUSED
 117 #define GETBYTE() (ld->op [ld->rx->n_bytes++] = ld->getbyte (ld->ptr))
 118
 119 #define SYNTAX(x) rx->syntax = x
 120
 121 #define UNSUPPORTED() \
 122   rx->syntax = "*unknown*"
 123
 124 #define IMM(sf)   immediate (sf, 0, ld)
 125 #define IMMex(sf) immediate (sf, 1, ld)
 126
 127 static int
 128 immediate (int sfield, int ex, LocalData * ld)
 129 {
 130   unsigned long i = 0, j;
 131
 132   switch (sfield)
 133     {
 134 #define B ((unsigned long) GETBYTE())
 135     case 0:
 136 #if RX_OPCODE_BIG_ENDIAN
 137       i  = B;
 138       if (ex && (i & 0x80))
 139         i -= 0x100;
 140       i <<= 24;
 141       i |= B << 16;
 142       i |= B << 8;
 143       i |= B;
 144 #else
 145       i = B;
 146       i |= B << 8;
 147       i |= B << 16;
 148       j = B;
 149       if (ex && (j & 0x80))
 150         j -= 0x100;
 151       i |= j << 24;
 152 #endif
 153       break;
 154     case 3:
 155 #if RX_OPCODE_BIG_ENDIAN
 156       i  = B << 16;
 157       i |= B << 8;
 158       i |= B;
 159 #else
 160       i  = B;
 161       i |= B << 8;
 162       i |= B << 16;
 163 #endif
 164       if (ex && (i & 0x800000))
 165         i -= 0x1000000;
 166       break;
 167     case 2:
 168 #if RX_OPCODE_BIG_ENDIAN
 169       i |= B << 8;
 170       i |= B;
 171 #else
 172       i |= B;
 173       i |= B << 8;
 174 #endif
 175       if (ex && (i & 0x8000))
 176         i -= 0x10000;
 177       break;
 178     case 1:
 179       i |= B;
 180       if (ex && (i & 0x80))
 181         i -= 0x100;
 182       break;
 183     default:
 184       abort();
 185     }
 186   return i;
 187 }
 188
 189 static void
 190 rx_disp (int n, int type, int reg, int size, LocalData * ld)
 191 {
 192   int disp;
 193
 194   ld->rx->op[n].reg = reg;
 195   switch (type)
 196     {
 197     case 3:
 198       ld->rx->op[n].type = RX_Operand_Register;
 199       break;
 200     case 0:
 201       ld->rx->op[n].type = RX_Operand_Indirect;
 202       ld->rx->op[n].addend = 0;
 203       break;
 204     case 1:
 205       ld->rx->op[n].type = RX_Operand_Indirect;
 206       disp = GETBYTE ();
 207       ld->rx->op[n].addend = disp * PSCALE[size];
 208       break;
 209     case 2:
 210       ld->rx->op[n].type = RX_Operand_Indirect;
 211       disp = GETBYTE ();
 212 #if RX_OPCODE_BIG_ENDIAN
 213       disp = disp * 256 + GETBYTE ();
 214 #else
 215       disp = disp + GETBYTE () * 256;
 216 #endif
 217       ld->rx->op[n].addend = disp * PSCALE[size];
 218       break;
 219     default:
 220       abort ();
 221     }
 222 }
 223
 224 /* The syntax is "OSZC" where each character is one of the following:
 225    - = flag unchanged
 226    0 = flag cleared
 227    1 = flag set
 228    ? = flag undefined
 229    x = flag set (any letter will do, use it for hints :).  */
 230
 231 static void
 232 store_flags (RX_Opcode_Decoded * rx, char * str)
 233 {
 234   int i, mask;
 235   rx->flags_0 = 0;
 236   rx->flags_1 = 0;
 237   rx->flags_s = 0;
 238
 239   for (i = 0; i < 4; i++)
 240     {
 241       mask = 8 >> i;
 242       switch (str[i])
 243         {
 244         case 0:
 245           abort ();
 246         case '-':
 247           break;
 248         case '0':
 249           rx->flags_0 |= mask;
 250           break;
 251         case '1':
 252           rx->flags_1 |= mask;
 253           break;
 254         case '?':
 255           break;
 256         default:
 257           rx->flags_0 |= mask;
 258           rx->flags_s |= mask;
 259           break;
 260         }
 261     }
 262 }
 263
 264 int
 265 rx_decode_opcode (unsigned long pc AU,
 266                   RX_Opcode_Decoded * rx,
 267                   int (* getbyte)(void *),
 268                   void * ptr)
 269 {
 270   LocalData lds, * ld = &lds;
 271   unsigned char op[20] = {0};
 272
 273   lds.rx = rx;
 274   lds.getbyte = getbyte;
 275   lds.ptr = ptr;
 276   lds.op = op;
 277
 278   memset (rx, 0, sizeof (*rx));
 279   BWL(LSIZE);
 280
 281
 282 /*----------------------------------------------------------------------*/
 283 /* MOV                                                                  */
 284
 285   GETBYTE ();
 286   switch (op[0] & 0xff)
 287   {
 288     case 0x00:
 289         {
 290           /** 0000 0000                 brk */
 291           if (trace)
 292             {
 293               printf ("\033[33m%s\033[0m  %02x\n",
 294                      "/** 0000 0000                     brk */",
 295                      op[0]);
 296             }
 297           SYNTAX("brk");
 298 #line 957 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 299           ID(brk);
 300
 301         }
 302       break;
 303     case 0x01:
 304         {
 305           /** 0000 0001                 dbt */
 306           if (trace)
 307             {
 308               printf ("\033[33m%s\033[0m  %02x\n",
 309                      "/** 0000 0001                     dbt */",
 310                      op[0]);
 311             }
 312           SYNTAX("dbt");
 313 #line 960 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 314           ID(dbt);
 315
 316         }
 317       break;
 318     case 0x02:
 319         {
 320           /** 0000 0010                 rts */
 321           if (trace)
 322             {
 323               printf ("\033[33m%s\033[0m  %02x\n",
 324                      "/** 0000 0010                     rts */",
 325                      op[0]);
 326             }
 327           SYNTAX("rts");
 328 #line 740 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 329           ID(rts);
 330
 331         /*----------------------------------------------------------------------*/
 332         /* NOP                                                          */
 333
 334         }
 335       break;
 336     case 0x03:
 337         {
 338           /** 0000 0011                 nop */
 339           if (trace)
 340             {
 341               printf ("\033[33m%s\033[0m  %02x\n",
 342                      "/** 0000 0011                     nop */",
 343                      op[0]);
 344             }
 345           SYNTAX("nop");
 346 #line 746 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 347           ID(nop);
 348
 349         /*----------------------------------------------------------------------*/
 350         /* STRING FUNCTIONS                                                     */
 351
 352         }
 353       break;
 354     case 0x04:
 355         {
 356           /** 0000 0100                 bra.a   %a0 */
 357           if (trace)
 358             {
 359               printf ("\033[33m%s\033[0m  %02x\n",
 360                      "/** 0000 0100                     bra.a   %a0 */",
 361                      op[0]);
 362             }
 363           SYNTAX("bra.a %a0");
 364 #line 718 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 365           ID(branch); Scc(RXC_always); DC(pc + IMMex(3));
 366
 367         }
 368       break;
 369     case 0x05:
 370         {
 371           /** 0000 0101                 bsr.a   %a0 */
 372           if (trace)
 373             {
 374               printf ("\033[33m%s\033[0m  %02x\n",
 375                      "/** 0000 0101                     bsr.a   %a0 */",
 376                      op[0]);
 377             }
 378           SYNTAX("bsr.a %a0");
 379 #line 734 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 380           ID(jsr); DC(pc + IMMex(3));
 381
 382         }
 383       break;
 384     case 0x06:
 385         GETBYTE ();
 386         switch (op[1] & 0xff)
 387         {
 388           case 0x00:
 389               GETBYTE ();
 390               switch (op[2] & 0x00)
 391               {
 392                 case 0x00:
 393                   op_semantics_1:
 394                     {
 395                       /** 0000 0110 mx00 00ss rsrc rdst                 sub     %2%S2, %1 */
 396 #line 521 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 397                       int mx AU = (op[1] >> 6) & 0x03;
 398 #line 521 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 399                       int ss AU = op[1] & 0x03;
 400 #line 521 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 401                       int rsrc AU = (op[2] >> 4) & 0x0f;
 402 #line 521 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 403                       int rdst AU = op[2] & 0x0f;
 404                       if (trace)
 405                         {
 406                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 407                                  "/** 0000 0110 mx00 00ss rsrc rdst                     sub     %2%S2, %1 */",
 408                                  op[0], op[1], op[2]);
 409                           printf ("  mx = 0x%x,", mx);
 410                           printf ("  ss = 0x%x,", ss);
 411                           printf ("  rsrc = 0x%x,", rsrc);
 412                           printf ("  rdst = 0x%x\n", rdst);
 413                         }
 414                       SYNTAX("sub       %2%S2, %1");
 415 #line 522 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 416                       ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F("OSZC");
 417
 418                     }
 419                   break;
 420               }
 421             break;
 422           case 0x01:
 423               GETBYTE ();
 424               switch (op[2] & 0x00)
 425               {
 426                 case 0x00:
 427                   goto op_semantics_1;
 428                   break;
 429               }
 430             break;
 431           case 0x02:
 432               GETBYTE ();
 433               switch (op[2] & 0x00)
 434               {
 435                 case 0x00:
 436                   goto op_semantics_1;
 437                   break;
 438               }
 439             break;
 440           case 0x03:
 441               GETBYTE ();
 442               switch (op[2] & 0x00)
 443               {
 444                 case 0x00:
 445                   goto op_semantics_1;
 446                   break;
 447               }
 448             break;
 449           case 0x04:
 450               GETBYTE ();
 451               switch (op[2] & 0x00)
 452               {
 453                 case 0x00:
 454                   op_semantics_2:
 455                     {
 456                       /** 0000 0110 mx00 01ss rsrc rdst         cmp     %2%S2, %1 */
 457 #line 509 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 458                       int mx AU = (op[1] >> 6) & 0x03;
 459 #line 509 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 460                       int ss AU = op[1] & 0x03;
 461 #line 509 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 462                       int rsrc AU = (op[2] >> 4) & 0x0f;
 463 #line 509 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 464                       int rdst AU = op[2] & 0x0f;
 465                       if (trace)
 466                         {
 467                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 468                                  "/** 0000 0110 mx00 01ss rsrc rdst             cmp     %2%S2, %1 */",
 469                                  op[0], op[1], op[2]);
 470                           printf ("  mx = 0x%x,", mx);
 471                           printf ("  ss = 0x%x,", ss);
 472                           printf ("  rsrc = 0x%x,", rsrc);
 473                           printf ("  rdst = 0x%x\n", rdst);
 474                         }
 475                       SYNTAX("cmp       %2%S2, %1");
 476 #line 510 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 477                       ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F("OSZC");
 478
 479                     /*----------------------------------------------------------------------*/
 480                     /* SUB                                                                      */
 481
 482                     }
 483                   break;
 484               }
 485             break;
 486           case 0x05:
 487               GETBYTE ();
 488               switch (op[2] & 0x00)
 489               {
 490                 case 0x00:
 491                   goto op_semantics_2;
 492                   break;
 493               }
 494             break;
 495           case 0x06:
 496               GETBYTE ();
 497               switch (op[2] & 0x00)
 498               {
 499                 case 0x00:
 500                   goto op_semantics_2;
 501                   break;
 502               }
 503             break;
 504           case 0x07:
 505               GETBYTE ();
 506               switch (op[2] & 0x00)
 507               {
 508                 case 0x00:
 509                   goto op_semantics_2;
 510                   break;
 511               }
 512             break;
 513           case 0x08:
 514               GETBYTE ();
 515               switch (op[2] & 0x00)
 516               {
 517                 case 0x00:
 518                   op_semantics_3:
 519                     {
 520                       /** 0000 0110 mx00 10ss rsrc rdst add     %1%S1, %0 */
 521 #line 485 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 522                       int mx AU = (op[1] >> 6) & 0x03;
 523 #line 485 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 524                       int ss AU = op[1] & 0x03;
 525 #line 485 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 526                       int rsrc AU = (op[2] >> 4) & 0x0f;
 527 #line 485 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 528                       int rdst AU = op[2] & 0x0f;
 529                       if (trace)
 530                         {
 531                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 532                                  "/** 0000 0110 mx00 10ss rsrc rdst     add     %1%S1, %0 */",
 533                                  op[0], op[1], op[2]);
 534                           printf ("  mx = 0x%x,", mx);
 535                           printf ("  ss = 0x%x,", ss);
 536                           printf ("  rsrc = 0x%x,", rsrc);
 537                           printf ("  rdst = 0x%x\n", rdst);
 538                         }
 539                       SYNTAX("add       %1%S1, %0");
 540 #line 486 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 541                       ID(add); SPm(ss, rsrc, mx); DR(rdst); F("OSZC");
 542
 543                     }
 544                   break;
 545               }
 546             break;
 547           case 0x09:
 548               GETBYTE ();
 549               switch (op[2] & 0x00)
 550               {
 551                 case 0x00:
 552                   goto op_semantics_3;
 553                   break;
 554               }
 555             break;
 556           case 0x0a:
 557               GETBYTE ();
 558               switch (op[2] & 0x00)
 559               {
 560                 case 0x00:
 561                   goto op_semantics_3;
 562                   break;
 563               }
 564             break;
 565           case 0x0b:
 566               GETBYTE ();
 567               switch (op[2] & 0x00)
 568               {
 569                 case 0x00:
 570                   goto op_semantics_3;
 571                   break;
 572               }
 573             break;
 574           case 0x0c:
 575               GETBYTE ();
 576               switch (op[2] & 0x00)
 577               {
 578                 case 0x00:
 579                   op_semantics_4:
 580                     {
 581                       /** 0000 0110 mx00 11ss rsrc rdst mul     %1%S1, %0 */
 582 #line 582 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 583                       int mx AU = (op[1] >> 6) & 0x03;
 584 #line 582 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 585                       int ss AU = op[1] & 0x03;
 586 #line 582 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 587                       int rsrc AU = (op[2] >> 4) & 0x0f;
 588 #line 582 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 589                       int rdst AU = op[2] & 0x0f;
 590                       if (trace)
 591                         {
 592                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 593                                  "/** 0000 0110 mx00 11ss rsrc rdst     mul     %1%S1, %0 */",
 594                                  op[0], op[1], op[2]);
 595                           printf ("  mx = 0x%x,", mx);
 596                           printf ("  ss = 0x%x,", ss);
 597                           printf ("  rsrc = 0x%x,", rsrc);
 598                           printf ("  rdst = 0x%x\n", rdst);
 599                         }
 600                       SYNTAX("mul       %1%S1, %0");
 601 #line 583 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 602                       ID(mul); SPm(ss, rsrc, mx); DR(rdst); F("O---");
 603
 604                     }
 605                   break;
 606               }
 607             break;
 608           case 0x0d:
 609               GETBYTE ();
 610               switch (op[2] & 0x00)
 611               {
 612                 case 0x00:
 613                   goto op_semantics_4;
 614                   break;
 615               }
 616             break;
 617           case 0x0e:
 618               GETBYTE ();
 619               switch (op[2] & 0x00)
 620               {
 621                 case 0x00:
 622                   goto op_semantics_4;
 623                   break;
 624               }
 625             break;
 626           case 0x0f:
 627               GETBYTE ();
 628               switch (op[2] & 0x00)
 629               {
 630                 case 0x00:
 631                   goto op_semantics_4;
 632                   break;
 633               }
 634             break;
 635           case 0x10:
 636               GETBYTE ();
 637               switch (op[2] & 0x00)
 638               {
 639                 case 0x00:
 640                   op_semantics_5:
 641                     {
 642                       /** 0000 0110 mx01 00ss rsrc rdst and     %1%S1, %0 */
 643 #line 398 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 644                       int mx AU = (op[1] >> 6) & 0x03;
 645 #line 398 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 646                       int ss AU = op[1] & 0x03;
 647 #line 398 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 648                       int rsrc AU = (op[2] >> 4) & 0x0f;
 649 #line 398 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 650                       int rdst AU = op[2] & 0x0f;
 651                       if (trace)
 652                         {
 653                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 654                                  "/** 0000 0110 mx01 00ss rsrc rdst     and     %1%S1, %0 */",
 655                                  op[0], op[1], op[2]);
 656                           printf ("  mx = 0x%x,", mx);
 657                           printf ("  ss = 0x%x,", ss);
 658                           printf ("  rsrc = 0x%x,", rsrc);
 659                           printf ("  rdst = 0x%x\n", rdst);
 660                         }
 661                       SYNTAX("and       %1%S1, %0");
 662 #line 399 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 663                       ID(and); SPm(ss, rsrc, mx); DR(rdst); F("-SZ-");
 664
 665                     }
 666                   break;
 667               }
 668             break;
 669           case 0x11:
 670               GETBYTE ();
 671               switch (op[2] & 0x00)
 672               {
 673                 case 0x00:
 674                   goto op_semantics_5;
 675                   break;
 676               }
 677             break;
 678           case 0x12:
 679               GETBYTE ();
 680               switch (op[2] & 0x00)
 681               {
 682                 case 0x00:
 683                   goto op_semantics_5;
 684                   break;
 685               }
 686             break;
 687           case 0x13:
 688               GETBYTE ();
 689               switch (op[2] & 0x00)
 690               {
 691                 case 0x00:
 692                   goto op_semantics_5;
 693                   break;
 694               }
 695             break;
 696           case 0x14:
 697               GETBYTE ();
 698               switch (op[2] & 0x00)
 699               {
 700                 case 0x00:
 701                   op_semantics_6:
 702                     {
 703                       /** 0000 0110 mx01 01ss rsrc rdst                 or      %1%S1, %0 */
 704 #line 416 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 705                       int mx AU = (op[1] >> 6) & 0x03;
 706 #line 416 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 707                       int ss AU = op[1] & 0x03;
 708 #line 416 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 709                       int rsrc AU = (op[2] >> 4) & 0x0f;
 710 #line 416 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 711                       int rdst AU = op[2] & 0x0f;
 712                       if (trace)
 713                         {
 714                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 715                                  "/** 0000 0110 mx01 01ss rsrc rdst                     or      %1%S1, %0 */",
 716                                  op[0], op[1], op[2]);
 717                           printf ("  mx = 0x%x,", mx);
 718                           printf ("  ss = 0x%x,", ss);
 719                           printf ("  rsrc = 0x%x,", rsrc);
 720                           printf ("  rdst = 0x%x\n", rdst);
 721                         }
 722                       SYNTAX("or        %1%S1, %0");
 723 #line 417 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 724                       ID(or); SPm(ss, rsrc, mx); DR(rdst); F("-SZ-");
 725
 726                     }
 727                   break;
 728               }
 729             break;
 730           case 0x15:
 731               GETBYTE ();
 732               switch (op[2] & 0x00)
 733               {
 734                 case 0x00:
 735                   goto op_semantics_6;
 736                   break;
 737               }
 738             break;
 739           case 0x16:
 740               GETBYTE ();
 741               switch (op[2] & 0x00)
 742               {
 743                 case 0x00:
 744                   goto op_semantics_6;
 745                   break;
 746               }
 747             break;
 748           case 0x17:
 749               GETBYTE ();
 750               switch (op[2] & 0x00)
 751               {
 752                 case 0x00:
 753                   goto op_semantics_6;
 754                   break;
 755               }
 756             break;
 757           case 0x20:
 758               GETBYTE ();
 759               switch (op[2] & 0xff)
 760               {
 761                 case 0x00:
 762                     GETBYTE ();
 763                     switch (op[3] & 0x00)
 764                     {
 765                       case 0x00:
 766                         op_semantics_7:
 767                           {
 768                             /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb     %1%S1, %0 */
 769 #line 534 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 770                             int mx AU = (op[1] >> 6) & 0x03;
 771 #line 534 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 772                             int sp AU = op[1] & 0x03;
 773 #line 534 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 774                             int rsrc AU = (op[3] >> 4) & 0x0f;
 775 #line 534 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 776                             int rdst AU = op[3] & 0x0f;
 777                             if (trace)
 778                               {
 779                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 780                                        "/** 0000 0110 mx10 00sp 0000 0000 rsrc rdst     sbb     %1%S1, %0 */",
 781                                        op[0], op[1], op[2], op[3]);
 782                                 printf ("  mx = 0x%x,", mx);
 783                                 printf ("  sp = 0x%x,", sp);
 784                                 printf ("  rsrc = 0x%x,", rsrc);
 785                                 printf ("  rdst = 0x%x\n", rdst);
 786                               }
 787                             SYNTAX("sbb %1%S1, %0");
 788 #line 535 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 789                             ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F("OSZC");
 790
 791                           /*----------------------------------------------------------------------*/
 792                           /* ABS                                                                        */
 793
 794                           }
 795                         break;
 796                     }
 797                   break;
 798                 case 0x04:
 799                     GETBYTE ();
 800                     switch (op[3] & 0x00)
 801                     {
 802                       case 0x00:
 803                         op_semantics_8:
 804                           {
 805                             /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max     %1%S1, %0 */
 806 #line 555 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 807                             int mx AU = (op[1] >> 6) & 0x03;
 808 #line 555 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 809                             int ss AU = op[1] & 0x03;
 810 #line 555 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 811                             int rsrc AU = (op[3] >> 4) & 0x0f;
 812 #line 555 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 813                             int rdst AU = op[3] & 0x0f;
 814                             if (trace)
 815                               {
 816                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 817                                        "/** 0000 0110 mx10 00ss 0000 0100 rsrc rdst     max     %1%S1, %0 */",
 818                                        op[0], op[1], op[2], op[3]);
 819                                 printf ("  mx = 0x%x,", mx);
 820                                 printf ("  ss = 0x%x,", ss);
 821                                 printf ("  rsrc = 0x%x,", rsrc);
 822                                 printf ("  rdst = 0x%x\n", rdst);
 823                               }
 824                             SYNTAX("max %1%S1, %0");
 825 #line 556 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 826                             ID(max); SPm(ss, rsrc, mx); DR(rdst);
 827
 828                           /*----------------------------------------------------------------------*/
 829                           /* MIN                                                                        */
 830
 831                           }
 832                         break;
 833                     }
 834                   break;
 835                 case 0x05:
 836                     GETBYTE ();
 837                     switch (op[3] & 0x00)
 838                     {
 839                       case 0x00:
 840                         op_semantics_9:
 841                           {
 842                             /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min     %1%S1, %0 */
 843 #line 567 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 844                             int mx AU = (op[1] >> 6) & 0x03;
 845 #line 567 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 846                             int ss AU = op[1] & 0x03;
 847 #line 567 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 848                             int rsrc AU = (op[3] >> 4) & 0x0f;
 849 #line 567 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 850                             int rdst AU = op[3] & 0x0f;
 851                             if (trace)
 852                               {
 853                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 854                                        "/** 0000 0110 mx10 00ss 0000 0101 rsrc rdst     min     %1%S1, %0 */",
 855                                        op[0], op[1], op[2], op[3]);
 856                                 printf ("  mx = 0x%x,", mx);
 857                                 printf ("  ss = 0x%x,", ss);
 858                                 printf ("  rsrc = 0x%x,", rsrc);
 859                                 printf ("  rdst = 0x%x\n", rdst);
 860                               }
 861                             SYNTAX("min %1%S1, %0");
 862 #line 568 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 863                             ID(min); SPm(ss, rsrc, mx); DR(rdst);
 864
 865                           /*----------------------------------------------------------------------*/
 866                           /* MUL                                                                        */
 867
 868                           }
 869                         break;
 870                     }
 871                   break;
 872                 case 0x06:
 873                     GETBYTE ();
 874                     switch (op[3] & 0x00)
 875                     {
 876                       case 0x00:
 877                         op_semantics_10:
 878                           {
 879                             /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul    %1%S1, %0 */
 880 #line 597 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 881                             int mx AU = (op[1] >> 6) & 0x03;
 882 #line 597 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 883                             int ss AU = op[1] & 0x03;
 884 #line 597 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 885                             int rsrc AU = (op[3] >> 4) & 0x0f;
 886 #line 597 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 887                             int rdst AU = op[3] & 0x0f;
 888                             if (trace)
 889                               {
 890                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 891                                        "/** 0000 0110 mx10 00ss 0000 0110 rsrc rdst     emul    %1%S1, %0 */",
 892                                        op[0], op[1], op[2], op[3]);
 893                                 printf ("  mx = 0x%x,", mx);
 894                                 printf ("  ss = 0x%x,", ss);
 895                                 printf ("  rsrc = 0x%x,", rsrc);
 896                                 printf ("  rdst = 0x%x\n", rdst);
 897                               }
 898                             SYNTAX("emul        %1%S1, %0");
 899 #line 598 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 900                             ID(emul); SPm(ss, rsrc, mx); DR(rdst);
 901
 902                           /*----------------------------------------------------------------------*/
 903                           /* EMULU                                                                      */
 904
 905                           }
 906                         break;
 907                     }
 908                   break;
 909                 case 0x07:
 910                     GETBYTE ();
 911                     switch (op[3] & 0x00)
 912                     {
 913                       case 0x00:
 914                         op_semantics_11:
 915                           {
 916                             /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu   %1%S1, %0 */
 917 #line 609 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 918                             int mx AU = (op[1] >> 6) & 0x03;
 919 #line 609 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 920                             int ss AU = op[1] & 0x03;
 921 #line 609 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 922                             int rsrc AU = (op[3] >> 4) & 0x0f;
 923 #line 609 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 924                             int rdst AU = op[3] & 0x0f;
 925                             if (trace)
 926                               {
 927                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 928                                        "/** 0000 0110 mx10 00ss 0000 0111 rsrc rdst     emulu   %1%S1, %0 */",
 929                                        op[0], op[1], op[2], op[3]);
 930                                 printf ("  mx = 0x%x,", mx);
 931                                 printf ("  ss = 0x%x,", ss);
 932                                 printf ("  rsrc = 0x%x,", rsrc);
 933                                 printf ("  rdst = 0x%x\n", rdst);
 934                               }
 935                             SYNTAX("emulu       %1%S1, %0");
 936 #line 610 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 937                             ID(emulu); SPm(ss, rsrc, mx); DR(rdst);
 938
 939                           /*----------------------------------------------------------------------*/
 940                           /* DIV                                                                        */
 941
 942                           }
 943                         break;
 944                     }
 945                   break;
 946                 case 0x08:
 947                     GETBYTE ();
 948                     switch (op[3] & 0x00)
 949                     {
 950                       case 0x00:
 951                         op_semantics_12:
 952                           {
 953                             /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div     %1%S1, %0 */
 954 #line 621 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 955                             int mx AU = (op[1] >> 6) & 0x03;
 956 #line 621 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 957                             int ss AU = op[1] & 0x03;
 958 #line 621 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 959                             int rsrc AU = (op[3] >> 4) & 0x0f;
 960 #line 621 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 961                             int rdst AU = op[3] & 0x0f;
 962                             if (trace)
 963                               {
 964                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 965                                        "/** 0000 0110 mx10 00ss 0000 1000 rsrc rdst     div     %1%S1, %0 */",
 966                                        op[0], op[1], op[2], op[3]);
 967                                 printf ("  mx = 0x%x,", mx);
 968                                 printf ("  ss = 0x%x,", ss);
 969                                 printf ("  rsrc = 0x%x,", rsrc);
 970                                 printf ("  rdst = 0x%x\n", rdst);
 971                               }
 972                             SYNTAX("div %1%S1, %0");
 973 #line 622 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 974                             ID(div); SPm(ss, rsrc, mx); DR(rdst); F("O---");
 975
 976                           /*----------------------------------------------------------------------*/
 977                           /* DIVU                                                                       */
 978
 979                           }
 980                         break;
 981                     }
 982                   break;
 983                 case 0x09:
 984                     GETBYTE ();
 985                     switch (op[3] & 0x00)
 986                     {
 987                       case 0x00:
 988                         op_semantics_13:
 989                           {
 990                             /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu    %1%S1, %0 */
 991 #line 633 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 992                             int mx AU = (op[1] >> 6) & 0x03;
 993 #line 633 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 994                             int ss AU = op[1] & 0x03;
 995 #line 633 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 996                             int rsrc AU = (op[3] >> 4) & 0x0f;
 997 #line 633 "/work/sources/gcc/current/opcodes/rx-decode.opc"
 998                             int rdst AU = op[3] & 0x0f;
 999                             if (trace)
1000                               {
1001                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1002                                        "/** 0000 0110 mx10 00ss 0000 1001 rsrc rdst     divu    %1%S1, %0 */",
1003                                        op[0], op[1], op[2], op[3]);
1004                                 printf ("  mx = 0x%x,", mx);
1005                                 printf ("  ss = 0x%x,", ss);
1006                                 printf ("  rsrc = 0x%x,", rsrc);
1007                                 printf ("  rdst = 0x%x\n", rdst);
1008                               }
1009                             SYNTAX("divu        %1%S1, %0");
1010 #line 634 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1011                             ID(divu); SPm(ss, rsrc, mx); DR(rdst); F("O---");
1012
1013                           /*----------------------------------------------------------------------*/
1014                           /* SHIFT                                                              */
1015
1016                           }
1017                         break;
1018                     }
1019                   break;
1020                 case 0x0c:
1021                     GETBYTE ();
1022                     switch (op[3] & 0x00)
1023                     {
1024                       case 0x00:
1025                         op_semantics_14:
1026                           {
1027                             /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst     %1%S1, %2 */
1028 #line 452 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1029                             int mx AU = (op[1] >> 6) & 0x03;
1030 #line 452 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1031                             int ss AU = op[1] & 0x03;
1032 #line 452 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1033                             int rsrc AU = (op[3] >> 4) & 0x0f;
1034 #line 452 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1035                             int rdst AU = op[3] & 0x0f;
1036                             if (trace)
1037                               {
1038                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1039                                        "/** 0000 0110 mx10 00ss 0000 1100 rsrc rdst     tst     %1%S1, %2 */",
1040                                        op[0], op[1], op[2], op[3]);
1041                                 printf ("  mx = 0x%x,", mx);
1042                                 printf ("  ss = 0x%x,", ss);
1043                                 printf ("  rsrc = 0x%x,", rsrc);
1044                                 printf ("  rdst = 0x%x\n", rdst);
1045                               }
1046                             SYNTAX("tst %1%S1, %2");
1047 #line 453 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1048                             ID(and); SPm(ss, rsrc, mx); S2R(rdst); F("-SZ-");
1049
1050                           /*----------------------------------------------------------------------*/
1051                           /* NEG                                                                        */
1052
1053                           }
1054                         break;
1055                     }
1056                   break;
1057                 case 0x0d:
1058                     GETBYTE ();
1059                     switch (op[3] & 0x00)
1060                     {
1061                       case 0x00:
1062                         op_semantics_15:
1063                           {
1064                             /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor     %1%S1, %0 */
1065 #line 431 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1066                             int mx AU = (op[1] >> 6) & 0x03;
1067 #line 431 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1068                             int ss AU = op[1] & 0x03;
1069 #line 431 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1070                             int rsrc AU = (op[3] >> 4) & 0x0f;
1071 #line 431 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1072                             int rdst AU = op[3] & 0x0f;
1073                             if (trace)
1074                               {
1075                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1076                                        "/** 0000 0110 mx10 00ss 0000 1101 rsrc rdst     xor     %1%S1, %0 */",
1077                                        op[0], op[1], op[2], op[3]);
1078                                 printf ("  mx = 0x%x,", mx);
1079                                 printf ("  ss = 0x%x,", ss);
1080                                 printf ("  rsrc = 0x%x,", rsrc);
1081                                 printf ("  rdst = 0x%x\n", rdst);
1082                               }
1083                             SYNTAX("xor %1%S1, %0");
1084 #line 432 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1085                             ID(xor); SPm(ss, rsrc, mx); DR(rdst); F("-SZ-");
1086
1087                           /*----------------------------------------------------------------------*/
1088                           /* NOT                                                                        */
1089
1090                           }
1091                         break;
1092                     }
1093                   break;
1094                 case 0x10:
1095                     GETBYTE ();
1096                     switch (op[3] & 0x00)
1097                     {
1098                       case 0x00:
1099                         op_semantics_16:
1100                           {
1101                             /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg    %1%S1, %0 */
1102 #line 365 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1103                             int mx AU = (op[1] >> 6) & 0x03;
1104 #line 365 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1105                             int ss AU = op[1] & 0x03;
1106 #line 365 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1107                             int rsrc AU = (op[3] >> 4) & 0x0f;
1108 #line 365 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1109                             int rdst AU = op[3] & 0x0f;
1110                             if (trace)
1111                               {
1112                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1113                                        "/** 0000 0110 mx10 00ss 0001 0000 rsrc rdst     xchg    %1%S1, %0 */",
1114                                        op[0], op[1], op[2], op[3]);
1115                                 printf ("  mx = 0x%x,", mx);
1116                                 printf ("  ss = 0x%x,", ss);
1117                                 printf ("  rsrc = 0x%x,", rsrc);
1118                                 printf ("  rdst = 0x%x\n", rdst);
1119                               }
1120                             SYNTAX("xchg        %1%S1, %0");
1121 #line 366 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1122                             ID(xchg); DR(rdst); SPm(ss, rsrc, mx);
1123
1124                           /*----------------------------------------------------------------------*/
1125                           /* STZ/STNZ                                                           */
1126
1127                           }
1128                         break;
1129                     }
1130                   break;
1131                 case 0x11:
1132                     GETBYTE ();
1133                     switch (op[3] & 0x00)
1134                     {
1135                       case 0x00:
1136                         op_semantics_17:
1137                           {
1138                             /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof    %1%S1, %0 */
1139 #line 862 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1140                             int mx AU = (op[1] >> 6) & 0x03;
1141 #line 862 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1142                             int sd AU = op[1] & 0x03;
1143 #line 862 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1144                             int rsrc AU = (op[3] >> 4) & 0x0f;
1145 #line 862 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1146                             int rdst AU = op[3] & 0x0f;
1147                             if (trace)
1148                               {
1149                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1150                                        "/** 0000 0110 mx10 00sd 0001 0001 rsrc rdst     itof    %1%S1, %0 */",
1151                                        op[0], op[1], op[2], op[3]);
1152                                 printf ("  mx = 0x%x,", mx);
1153                                 printf ("  sd = 0x%x,", sd);
1154                                 printf ("  rsrc = 0x%x,", rsrc);
1155                                 printf ("  rdst = 0x%x\n", rdst);
1156                               }
1157                             SYNTAX("itof        %1%S1, %0");
1158 #line 863 "/work/sources/gcc/current/opcodes/rx-decode.opc"
1159                             ID(itof); DR (rdst); SPm(sd, rsrc, mx); F("-SZ-");
1160
1161                           /*----------------------------------------------------------------------*/
1162                           /* BIT OPS                                                            */
1163
1164                           }
1165                         break;
1166                     }
1167                   break;
1168                 default: UNSUPPORTED(); break;
1169               }
1170             break;
1171           case 0x21:
1172               GETBYTE ();
1173               switch (op[2] & 0xff)
1174               {
1175                 case 0x00:
1176                     GETBYTE ();
1177                     switch (op[3] & 0x00)
1178                     {
1179                       case 0x00:
1180                         goto op_semantics_7;
1181                         break;
1182                     }
1183                   break;
1184                 case 0x04:
1185                     GETBYTE ();
1186                     switch (op[3] & 0x00)
1187                     {
1188                       case 0x00:
1189                         goto op_semantics_8;
1190                         break;
1191                     }
1192                   break;
1193                 case 0x05:
1194                     GETBYTE ();
1195                     switch (op[3] & 0x00)
1196                     {
1197                       case 0x00:
1198                         goto op_semantics_9;
1199                         break;
1200                     }
1201                   break;
1202                 case 0x06:
1203                     GETBYTE ();
1204                     switch (op[3] & 0x00)
1205                     {
1206                       case 0x00:
1207                         goto op_semantics_10;
1208                         break;
1209                     }
1210                   break;
1211                 case 0x07:
1212                     GETBYTE ();
1213                     switch (op[3] & 0x00)
1214                     {
1215                       case 0x00:
1216                         goto op_semantics_11;
1217                         break;
1218                     }
1219                   break;
1220                 case 0x08:
1221                     GETBYTE ();
1222                     switch (op[3] & 0x00)
1223                     {
1224                       case 0x00:
1225                         goto op_semantics_12;
1226                         break;
1227                     }
1228                   break;
1229                 case 0x09:
1230                     GETBYTE ();
1231                     switch (op[3] & 0x00)
1232                     {
1233                       case 0x00:
1234                         goto op_semantics_13;
1235                         break;
1236                     }
1237                   break;
1238                 case 0x0c:
1239                     GETBYTE ();
1240                     switch (op[3] & 0x00)
1241                     {
1242                       case 0x00:
1243                         goto op_semantics_14;
1244                         break;
1245                     }
1246                   break;
1247                 case 0x0d:
1248                     GETBYTE ();
1249                     switch (op[3] & 0x00)
1250                     {
1251                       case 0x00:
1252                         goto op_semantics_15;
1253                         break;
1254                     }
1255                   break;
1256                 case 0x10:
1257                     GETBYTE ();
1258                     switch (op[3] & 0x00)
1259                     {
1260                       case 0x00:
1261                         goto op_semantics_16;
1262                         break;
1263                     }
1264                   break;
1265                 case 0x11:
1266                     GETBYTE ();
1267                     switch (op[3] & 0x00)
1268                     {
1269                       case 0x00:
1270                         goto op_semantics_17;
1271                         break;
1272                     }
1273                   break;
1274                 default: UNSUPPORTED(); break;
1275               }
1276             break;
1277           case 0x22:
1278               GETBYTE ();
1279               switch (op[2] & 0xff)
1280               {
1281                 case 0x00:
1282                     GETBYTE ();
1283                     switch (op[3] & 0x00)
1284                     {
1285                       case 0x00:
1286                         goto op_semantics_7;
1287                         break;
1288                     }
1289                   break;
1290                 case 0x04:
1291                     GETBYTE ();
1292                     switch (op[3] & 0x00)
1293                     {
1294                       case 0x00:
1295                         goto op_semantics_8;
1296                         break;
1297                     }
1298                   break;
1299                 case 0x05:
1300                     GETBYTE ();
1301                     switch (op[3] & 0x00)
1302                     {
1303                       case 0x00:
1304                         goto op_semantics_9;
1305                         break;
1306                     }
1307                   break;
1308                 case 0x06:
1309                     GETBYTE ();
1310                     switch (op[3] & 0x00)
1311                     {
1312                       case 0x00:
1313                         goto op_semantics_10;
1314                         break;
1315                     }
1316                   break;
1317                 case 0x07:
1318                     GETBYTE ();
1319                     switch (op[3] & 0x00)
1320                     {
1321                       case 0x00:
1322                         goto op_semantics_11;
1323                         break;
1324                     }
1325                   break;
1326                 case 0x08:
1327                     GETBYTE ();
1328                     switch (op[3] & 0x00)
1329                     {
1330                       case 0x00:
1331                         goto op_semantics_12;
1332                         break;
1333                     }
1334                   break;
1335                 case 0x09:
1336                     GETBYTE ();
1337                     switch (op[3] & 0x00)
1338                     {
1339                       case 0x00:
1340                         goto op_semantics_13;
1341                         break;
1342                     }
1343                   break;
1344                 case 0x0c:
1345                     GETBYTE ();
1346                     switch (op[3] & 0x00)
1347                     {
1348                       case 0x00:
1349                         goto op_semantics_14;
1350                         break;
1351                     }
1352                   break;
1353                 case 0x0d:
1354                     GETBYTE ();
1355                     switch (op[3] & 0x00)
1356                     {
1357                       case 0x00:
1358                         goto op_semantics_15;
1359                         break;
1360                     }
1361                   break;
1362                 case 0x10:
1363                     GETBYTE ();
1364                     switch (op[3] & 0x00)
1365                     {
1366                       case 0x00:
1367                         goto op_semantics_16;
1368                         break;
1369                     }
1370                   break;
1371                 case 0x11:
1372                     GETBYTE ();
1373                     switch (op[3] & 0x00)
1374                     {
1375                       case 0x00:
1376                         goto op_semantics_17;
1377                         break;
1378                     }
1379                   break;
1380                 default: UNSUPPORTED(); break;
1381               }
1382             break;
1383           case 0x23:
1384               GETBYTE ();
1385               switch (op[2] & 0xff)
1386               {
1387                 case 0x00:
1388                     GETBYTE ();
1389                     switch (op[3] & 0x00)
1390                     {
1391                       case 0x00:
1392                         goto op_semantics_7;
1393                         break;
1394                     }
1395                   break;
1396                 case 0x04:
1397                     GETBYTE ();
1398                     switch (op[3] & 0x00)
1399                     {
1400                       case 0x00:
1401                         goto op_semantics_8;
1402                         break;
1403                     }
1404                   break;
1405                 case 0x05:
1406                     GETBYTE ();
1407                     switch (op[3] & 0x00)
1408                     {
1409                       case 0x00:
1410                         goto op_semantics_9;
1411                         break;
1412                     }
1413                   break;
1414                 case 0x06:
1415                     GETBYTE ();
1416                     switch (op[3] & 0x00)
1417                     {
1418                       case 0x00:
1419                         goto op_semantics_10;
1420                         break;
1421                     }
1422                   break;
1423                 case 0x07:
1424                     GETBYTE ();
1425                     switch (op[3] & 0x00)
1426                     {
1427                       case 0x00:
1428                         goto op_semantics_11;
1429                         break;
1430                     }
1431                   break;
1432                 case 0x08:
1433                     GETBYTE ();
1434                     switch (op[3] & 0x00)
1435                     {
1436                       case 0x00:
1437                         goto op_semantics_12;
1438                         break;
1439                     }
1440                   break;
1441                 case 0x09:
1442                     GETBYTE ();
1443                     switch (op[3] & 0x00)
1444                     {
1445                       case 0x00:
1446                         goto op_semantics_13;
1447                         break;
1448                     }
1449                   break;
1450                 case 0x0c:
1451                     GETBYTE ();
1452                     switch (op[3] & 0x00)
1453                     {
1454                       case 0x00:
1455                         goto op_semantics_14;
1456                         break;
1457                     }
1458                   break;
1459                 case 0x0d:
1460                     GETBYTE ();
1461                     switch (op[3] & 0x00)
1462                     {
1463                       case 0x00:
1464                         goto op_semantics_15;
1465                         break;
1466                     }
1467                   break;
1468                 case 0x10:
1469                     GETBYTE ();
1470                     switch (op[3] & 0x00)
1471                     {
1472                       case 0x00:
1473                         goto op_semantics_16;
1474                         break;
1475                     }
1476                   break;
1477                 case 0x11:
1478                     GETBYTE ();
1479                     switch (op[3] & 0x00)
1480                     {
1481                       case 0x00:
1482                         goto op_semantics_17;
1483                         break;
1484                     }
1485                   break;
1486                 default: UNSUPPORTED(); break;
1487               }
1488             break;
1489           case 0x40:
1490               GETBYTE ();
1491               switch (op[2] & 0x00)
1492               {
1493                 case 0x00:
1494                   goto op_semantics_1;
1495                   break;
1496               }
1497             break;
1498           case 0x41:
1499               GETBYTE ();
1500               switch (op[2] & 0x00)
1501               {
1502                 case 0x00:
1503                   goto op_semantics_1;
1504                   break;
1505               }
1506             break;
1507           case 0x42:
1508               GETBYTE ();
1509               switch (op[2] & 0x00)
1510               {
1511                 case 0x00:
1512                   goto op_semantics_1;
1513                   break;
1514               }
1515             break;
1516           case 0x43:
1517               GETBYTE ();
1518               switch (op[2] & 0x00)
1519               {
1520                 case 0x00:
1521                   goto op_semantics_1;
1522                   break;
1523               }
1524             break;
1525           case 0x44:
1526               GETBYTE ();
1527               switch (op[2] & 0x00)
1528               {
1529                 case 0x00:
1530                   goto op_semantics_2;
1531                   break;
1532               }
1533             break;
1534           case 0x45:
1535               GETBYTE ();
1536               switch (op[2] & 0x00)
1537               {
1538                 case 0x00:
1539                   goto op_semantics_2;
1540                   break;
1541               }
1542             break;
1543           case 0x46:
1544               GETBYTE ();
1545               switch (op[2] & 0x00)
1546               {
1547                 case 0x00:
1548                   goto op_semantics_2;
1549                   break;
1550               }
1551             break;
1552           case 0x47:
1553               GETBYTE ();
1554               switch (op[2] & 0x00)
1555               {
1556                 case 0x00:
1557                   goto op_semantics_2;
1558                   break;
1559               }
1560             break;
1561           case 0x48:
1562               GETBYTE ();
1563               switch (op[2] & 0x00)
1564               {
1565                 case 0x00:
1566                   goto op_semantics_3;
1567                   break;
1568               }
1569             break;
1570           case 0x49:
1571               GETBYTE ();
1572               switch (op[2] & 0x00)
1573               {
1574                 case 0x00:
1575                   goto op_semantics_3;
1576                   break;
1577               }
1578             break;
1579           case 0x4a:
1580               GETBYTE ();
1581               switch (op[2] & 0x00)
1582               {
1583                 case 0x00:
1584                   goto op_semantics_3;
1585                   break;
1586               }
1587             break;
1588           case 0x4b:
1589               GETBYTE ();
1590               switch (op[2] & 0x00)
1591               {
1592                 case 0x00:
1593                   goto op_semantics_3;
1594                   break;
1595               }
1596             break;
1597           case 0x4c:
1598               GETBYTE ();
1599               switch (op[2] & 0x00)
1600               {
1601                 case 0x00:
1602                   goto op_semantics_4;
1603                   break;
1604               }
1605             break;
1606           case 0x4d:
1607               GETBYTE ();
1608               switch (op[2] & 0x00)
1609               {
1610                 case 0x00:
1611                   goto op_semantics_4;
1612                   break;
1613               }
1614             break;
1615           case 0x4e:
1616               GETBYTE ();
1617               switch (op[2] & 0x00)
1618               {
1619                 case 0x00:
1620                   goto op_semantics_4;
1621                   break;
1622               }
1623             break;
1624           case 0x4f:
1625               GETBYTE ();
1626               switch (op[2] & 0x00)
1627               {
1628                 case 0x00:
1629                   goto op_semantics_4;
1630                   break;
1631               }
1632             break;
1633           case 0x50:
1634               GETBYTE ();
1635               switch (op[2] & 0x00)
1636               {
1637                 case 0x00:
1638                   goto op_semantics_5;
1639                   break;
1640               }
1641             break;
1642           case 0x51:
1643               GETBYTE ();
1644               switch (op[2] & 0x00)
1645               {
1646                 case 0x00:
1647                   goto op_semantics_5;
1648                   break;
1649               }
1650             break;
1651           case 0x52:
1652               GETBYTE ();
1653               switch (op[2] & 0x00)
1654               {
1655                 case 0x00:
1656                   goto op_semantics_5;
1657                   break;
1658               }
1659             break;
1660           case 0x53:
1661               GETBYTE ();
1662               switch (op[2] & 0x00)
1663               {
1664                 case 0x00:
1665                   goto op_semantics_5;
1666                   break;
1667               }
1668             break;
1669           case 0x54:
1670               GETBYTE ();
1671               switch (op[2] & 0x00)
1672               {
1673                 case 0x00:
1674                   goto op_semantics_6;
1675                   break;
1676               }
1677             break;
1678           case 0x55:
1679               GETBYTE ();
1680               switch (op[2] & 0x00)
1681               {
1682                 case 0x00:
1683                   goto op_semantics_6;
1684                   break;
1685               }
1686             break;
1687           case 0x56:
1688               GETBYTE ();
1689               switch (op[2] & 0x00)
1690               {
1691                 case 0x00:
1692                   goto op_semantics_6;
1693                   break;
1694               }
1695             break;
1696           case 0x57:
1697               GETBYTE ();
1698               switch (op[2] & 0x00)
1699               {
1700                 case 0x00:
1701                   goto op_semantics_6;
1702                   break;
1703               }
1704             break;
1705           case 0x60:
1706               GETBYTE ();
1707               switch (op[2] & 0xff)
1708               {
1709                 case 0x00:
1710                     GETBYTE ();
1711                     switch (op[3] & 0x00)
1712                     {
1713                       case 0x00:
1714                         goto op_semantics_7;
1715                         break;
1716                     }
1717                   break;
1718                 case 0x04:
1719                     GETBYTE ();
1720                     switch (op[3] & 0x00)
1721                     {
1722                       case 0x00:
1723                         goto op_semantics_8;
1724                         break;
1725                     }
1726                   break;
1727                 case 0x05:
1728                     GETBYTE ();
1729                     switch (op[3] & 0x00)
1730                     {
1731                       case 0x00:
1732                         goto op_semantics_9;
1733                         break;
1734                     }
1735                   break;
1736                 case 0x06:
1737                     GETBYTE ();
1738                     switch (op[3] & 0x00)
1739                     {
1740                       case 0x00:
1741                         goto op_semantics_10;
1742                         break;
1743                     }
1744                   break;
1745                 case 0x07:
1746                     GETBYTE ();
1747                     switch (op[3] & 0x00)
1748                     {
1749                       case 0x00:
1750                         goto op_semantics_11;
1751                         break;
1752                     }
1753                   break;
1754                 case 0x08:
1755                     GETBYTE ();
1756                     switch (op[3] & 0x00)
1757                     {
1758                       case 0x00:
1759                         goto op_semantics_12;
1760                         break;
1761                     }
1762                   break;
1763                 case 0x09:
1764                     GETBYTE ();
1765                     switch (op[3] & 0x00)
1766                     {
1767                       case 0x00:
1768                         goto op_semantics_13;
1769                         break;
1770                     }
1771                   break;
1772                 case 0x0c:
1773                     GETBYTE ();
1774                     switch (op[3] & 0x00)
1775                     {
1776                       case 0x00:
1777                         goto op_semantics_14;
1778                         break;
1779                     }
1780                   break;
1781                 case 0x0d:
1782                     GETBYTE ();
1783                     switch (op[3] & 0x00)
1784                     {
1785                       case 0x00:
1786                         goto op_semantics_15;
1787                         break;
1788                     }
1789                   break;
1790                 case 0x10:
1791                     GETBYTE ();
1792                     switch (op[3] & 0x00)
1793                     {
1794                       case 0x00:
1795                         goto op_semantics_16;
1796                         break;
1797                     }
1798                   break;
1799                 case 0x11:
1800                     GETBYTE ();
1801                     switch (op[3] & 0x00)
1802                     {
1803                       case 0x00:
1804                         goto op_semantics_17;
1805                         break;
1806                     }
1807                   break;
1808                 default: UNSUPPORTED(); break;
1809               }
1810             break;
1811           case 0x61:
1812               GETBYTE ();
1813               switch (op[2] & 0xff)
1814               {
1815                 case 0x00:
1816                     GETBYTE ();
1817                     switch (op[3] & 0x00)
1818                     {
1819                       case 0x00:
1820                         goto op_semantics_7;
1821                         break;
1822                     }
1823                   break;
1824                 case 0x04:
1825                     GETBYTE ();
1826                     switch (op[3] & 0x00)
1827                     {
1828                       case 0x00:
1829                         goto op_semantics_8;
1830                         break;
1831                     }
1832                   break;
1833                 case 0x05:
1834                     GETBYTE ();
1835                     switch (op[3] & 0x00)
1836                     {
1837                       case 0x00:
1838                         goto op_semantics_9;
1839                         break;
1840                     }
1841                   break;
1842                 case 0x06:
1843                     GETBYTE ();
1844                     switch (op[3] & 0x00)
1845                     {
1846                       case 0x00:
1847                         goto op_semantics_10;
1848                         break;
1849                     }
1850                   break;
1851                 case 0x07:
1852                     GETBYTE ();
1853                     switch (op[3] & 0x00)
1854                     {
1855                       case 0x00:
1856                         goto op_semantics_11;
1857                         break;
1858                     }
1859                   break;
1860                 case 0x08:
1861                     GETBYTE ();
1862                     switch (op[3] & 0x00)
1863                     {
1864                       case 0x00:
1865                         goto op_semantics_12;
1866                         break;
1867                     }
1868                   break;
1869                 case 0x09:
1870                     GETBYTE ();
1871                     switch (op[3] & 0x00)
1872                     {
1873                       case 0x00:
1874                         goto op_semantics_13;
1875                         break;
1876                     }
1877                   break;
1878                 case 0x0c:
1879                     GETBYTE ();
1880                     switch (op[3] & 0x00)
1881                     {
1882                       case 0x00:
1883                         goto op_semantics_14;
1884                         break;
1885                     }
1886                   break;
1887                 case 0x0d:
1888                     GETBYTE ();
1889                     switch (op[3] & 0x00)
1890                     {
1891                       case 0x00:
1892                         goto op_semantics_15;
1893                         break;
1894                     }
1895                   break;
1896                 case 0x10:
1897                     GETBYTE ();
1898                     switch (op[3] & 0x00)
1899                     {
1900                       case 0x00:
1901                         goto op_semantics_16;
1902                         break;
1903                     }
1904                   break;
1905                 case 0x11:
1906                     GETBYTE ();
1907                     switch (op[3] & 0x00)
1908                     {
1909                       case 0x00:
1910                         goto op_semantics_17;
1911                         break;
1912                     }
1913                   break;
1914                 default: UNSUPPORTED(); break;
1915               }
1916             break;
1917           case 0x62:
1918               GETBYTE ();
1919               switch (op[2] & 0xff)
1920               {
1921                 case 0x00:
1922                     GETBYTE ();
1923                     switch (op[3] & 0x00)
1924                     {
1925                       case 0x00:
1926                         goto op_semantics_7;
1927                         break;
1928                     }
1929                   break;
1930                 case 0x04:
1931                     GETBYTE ();
1932                     switch (op[3] & 0x00)
1933                     {
1934                       case 0x00:
1935                         goto op_semantics_8;
1936                         break;
1937                     }
1938                   break;
1939                 case 0x05:
1940                     GETBYTE ();
1941                     switch (op[3] & 0x00)
1942                     {
1943                       case 0x00:
1944                         goto op_semantics_9;
1945                         break;
1946                     }
1947                   break;
1948                 case 0x06:
1949                     GETBYTE ();
1950                     switch (op[3] & 0x00)
1951                     {
1952                       case 0x00:
1953                         goto op_semantics_10;
1954                         break;
1955                     }
1956                   break;
1957                 case 0x07:
1958                     GETBYTE ();
1959                     switch (op[3] & 0x00)
1960                     {
1961                       case 0x00:
1962                         goto op_semantics_11;
1963                         break;
1964                     }
1965                   break;
1966                 case 0x08:
1967                     GETBYTE ();
1968                     switch (op[3] & 0x00)
1969                     {
1970                       case 0x00:
1971                         goto op_semantics_12;
1972                         break;
1973                     }
1974                   break;
1975                 case 0x09:
1976                     GETBYTE ();
1977                     switch (op[3] & 0x00)
1978                     {
1979                       case 0x00:
1980                         goto op_semantics_13;
1981                         break;
1982                     }
1983                   break;
1984                 case 0x0c:
1985                     GETBYTE ();
1986                     switch (op[3] & 0x00)
1987                     {
1988                       case 0x00:
1989                         goto op_semantics_14;
1990                         break;
1991                     }
1992                   break;
1993                 case 0x0d:
1994                     GETBYTE ();
1995                     switch (op[3] & 0x00)
1996                     {
1997                       case 0x00:
1998                         goto op_semantics_15;
1999                         break;
2000                     }
2001                   break;
2002                 case 0x10:
2003                     GETBYTE ();
2004                     switch (op[3] & 0x00)
2005                     {
2006                       case 0x00:
2007                         goto op_semantics_16;
2008                         break;
2009                     }
2010                   break;
2011                 case 0x11:
2012                     GETBYTE ();
2013                     switch (op[3] & 0x00)
2014                     {
2015                       case 0x00:
2016                         goto op_semantics_17;
2017                         break;
2018                     }
2019                   break;
2020                 default: UNSUPPORTED(); break;
2021               }
2022             break;
2023           case 0x63:
2024               GETBYTE ();
2025               switch (op[2] & 0xff)
2026               {
2027                 case 0x00:
2028                     GETBYTE ();
2029                     switch (op[3] & 0x00)
2030                     {
2031                       case 0x00:
2032                         goto op_semantics_7;
2033                         break;
2034                     }
2035                   break;
2036                 case 0x04:
2037                     GETBYTE ();
2038                     switch (op[3] & 0x00)
2039                     {
2040                       case 0x00:
2041                         goto op_semantics_8;
2042                         break;
2043                     }
2044                   break;
2045                 case 0x05:
2046                     GETBYTE ();
2047                     switch (op[3] & 0x00)
2048                     {
2049                       case 0x00:
2050                         goto op_semantics_9;
2051                         break;
2052                     }
2053                   break;
2054                 case 0x06:
2055                     GETBYTE ();
2056                     switch (op[3] & 0x00)
2057                     {
2058                       case 0x00:
2059                         goto op_semantics_10;
2060                         break;
2061                     }
2062                   break;
2063                 case 0x07:
2064                     GETBYTE ();
2065                     switch (op[3] & 0x00)
2066                     {
2067                       case 0x00:
2068                         goto op_semantics_11;
2069                         break;
2070                     }
2071                   break;
2072                 case 0x08:
2073                     GETBYTE ();
2074                     switch (op[3] & 0x00)
2075                     {
2076                       case 0x00:
2077                         goto op_semantics_12;
2078                         break;
2079                     }
2080                   break;
2081                 case 0x09:
2082                     GETBYTE ();
2083                     switch (op[3] & 0x00)
2084                     {
2085                       case 0x00:
2086                         goto op_semantics_13;
2087                         break;
2088                     }
2089                   break;
2090                 case 0x0c:
2091                     GETBYTE ();
2092                     switch (op[3] & 0x00)
2093                     {
2094                       case 0x00:
2095                         goto op_semantics_14;
2096                         break;
2097                     }
2098                   break;
2099                 case 0x0d:
2100                     GETBYTE ();
2101                     switch (op[3] & 0x00)
2102                     {
2103                       case 0x00:
2104                         goto op_semantics_15;
2105                         break;
2106                     }
2107                   break;
2108                 case 0x10:
2109                     GETBYTE ();
2110                     switch (op[3] & 0x00)
2111                     {
2112                       case 0x00:
2113                         goto op_semantics_16;
2114                         break;
2115                     }
2116                   break;
2117                 case 0x11:
2118                     GETBYTE ();
2119                     switch (op[3] & 0x00)
2120                     {
2121                       case 0x00:
2122                         goto op_semantics_17;
2123                         break;
2124                     }
2125                   break;
2126                 default: UNSUPPORTED(); break;
2127               }
2128             break;
2129           case 0x80:
2130               GETBYTE ();
2131               switch (op[2] & 0x00)
2132               {
2133                 case 0x00:
2134                   goto op_semantics_1;
2135                   break;
2136               }
2137             break;
2138           case 0x81:
2139               GETBYTE ();
2140               switch (op[2] & 0x00)
2141               {
2142                 case 0x00:
2143                   goto op_semantics_1;
2144                   break;
2145               }
2146             break;
2147           case 0x82:
2148               GETBYTE ();
2149               switch (op[2] & 0x00)
2150               {
2151                 case 0x00:
2152                   goto op_semantics_1;
2153                   break;
2154               }
2155             break;
2156           case 0x83:
2157               GETBYTE ();
2158               switch (op[2] & 0x00)
2159               {
2160                 case 0x00:
2161                   goto op_semantics_1;
2162                   break;
2163               }
2164             break;
2165           case 0x84:
2166               GETBYTE ();
2167               switch (op[2] & 0x00)
2168               {
2169                 case 0x00:
2170                   goto op_semantics_2;
2171                   break;
2172               }
2173             break;
2174           case 0x85:
2175               GETBYTE ();
2176               switch (op[2] & 0x00)
2177               {
2178                 case 0x00:
2179                   goto op_semantics_2;
2180                   break;
2181               }
2182             break;
2183           case 0x86:
2184               GETBYTE ();
2185               switch (op[2] & 0x00)
2186               {
2187                 case 0x00:
2188                   goto op_semantics_2;
2189                   break;
2190               }
2191             break;
2192           case 0x87:
2193               GETBYTE ();
2194               switch (op[2] & 0x00)
2195               {
2196                 case 0x00:
2197                   goto op_semantics_2;
2198                   break;
2199               }
2200             break;
2201           case 0x88:
2202               GETBYTE ();
2203               switch (op[2] & 0x00)
2204               {
2205                 case 0x00:
2206                   goto op_semantics_3;
2207                   break;
2208               }
2209             break;
2210           case 0x89:
2211               GETBYTE ();
2212               switch (op[2] & 0x00)
2213               {
2214                 case 0x00:
2215                   goto op_semantics_3;
2216                   break;
2217               }
2218             break;
2219           case 0x8a:
2220               GETBYTE ();
2221               switch (op[2] & 0x00)
2222               {
2223                 case 0x00:
2224                   goto op_semantics_3;
2225                   break;
2226               }
2227             break;
2228           case 0x8b:
2229               GETBYTE ();
2230               switch (op[2] & 0x00)
2231               {
2232                 case 0x00:
2233                   goto op_semantics_3;
2234                   break;
2235               }
2236             break;
2237           case 0x8c:
2238               GETBYTE ();
2239               switch (op[2] & 0x00)
2240               {
2241                 case 0x00:
2242                   goto op_semantics_4;
2243                   break;
2244               }
2245             break;
2246           case 0x8d:
2247               GETBYTE ();
2248               switch (op[2] & 0x00)
2249               {
2250                 case 0x00:
2251                   goto op_semantics_4;
2252                   break;
2253               }
2254             break;
2255           case 0x8e:
2256               GETBYTE ();
2257               switch (op[2] & 0x00)
2258               {
2259                 case 0x00:
2260                   goto op_semantics_4;
2261                   break;
2262               }
2263             break;
2264           case 0x8f:
2265               GETBYTE ();
2266               switch (op[2] & 0x00)
2267               {
2268                 case 0x00:
2269                   goto op_semantics_4;
2270                   break;
2271               }
2272             break;
2273           case 0x90:
2274               GETBYTE ();
2275               switch (op[2] & 0x00)
2276               {
2277                 case 0x00:
2278                   goto op_semantics_5;
2279                   break;
2280               }
2281             break;
2282           case 0x91:
2283               GETBYTE ();
2284               switch (op[2] & 0x00)
2285               {
2286                 case 0x00:
2287                   goto op_semantics_5;
2288                   break;
2289               }
2290             break;
2291           case 0x92:
2292               GETBYTE ();
2293               switch (op[2] & 0x00)
2294               {
2295                 case 0x00:
2296                   goto op_semantics_5;
2297                   break;
2298               }
2299             break;
2300           case 0x93:
2301               GETBYTE ();
2302               switch (op[2] & 0x00)
2303               {
2304                 case 0x00:
2305                   goto op_semantics_5;
2306                   break;
2307               }
2308             break;
2309           case 0x94:
2310               GETBYTE ();
2311               switch (op[2] & 0x00)
2312               {
2313                 case 0x00:
2314                   goto op_semantics_6;
2315                   break;
2316               }
2317             break;
2318           case 0x95:
2319               GETBYTE ();
2320               switch (op[2] & 0x00)
2321               {
2322                 case 0x00:
2323                   goto op_semantics_6;
2324                   break;
2325               }
2326             break;
2327           case 0x96:
2328               GETBYTE ();
2329               switch (op[2] & 0x00)
2330               {
2331                 case 0x00:
2332                   goto op_semantics_6;
2333                   break;
2334               }
2335             break;
2336           case 0x97:
2337               GETBYTE ();
2338               switch (op[2] & 0x00)
2339               {
2340                 case 0x00:
2341                   goto op_semantics_6;
2342                   break;
2343               }
2344             break;
2345           case 0xa0:
2346               GETBYTE ();
2347               switch (op[2] & 0xff)
2348               {
2349                 case 0x00:
2350                     GETBYTE ();
2351                     switch (op[3] & 0x00)
2352                     {
2353                       case 0x00:
2354                         goto op_semantics_7;
2355                         break;
2356                     }
2357                   break;
2358                 case 0x02:
2359                     GETBYTE ();
2360                     switch (op[3] & 0x00)
2361                     {
2362                       case 0x00:
2363                         op_semantics_18:
2364                           {
2365                             /** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc     %1%S1, %0 */
2366 #line 473 "/work/sources/gcc/current/opcodes/rx-decode.opc"
2367                             int ss AU = op[1] & 0x03;
2368 #line 473 "/work/sources/gcc/current/opcodes/rx-decode.opc"
2369                             int rsrc AU = (op[3] >> 4) & 0x0f;
2370 #line 473 "/work/sources/gcc/current/opcodes/rx-decode.opc"
2371                             int rdst AU = op[3] & 0x0f;
2372                             if (trace)
2373                               {
2374                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
2375                                        "/** 0000 0110 1010 00ss 0000 0010 rsrc rdst     adc     %1%S1, %0 */",
2376                                        op[0], op[1], op[2], op[3]);
2377                                 printf ("  ss = 0x%x,", ss);
2378                                 printf ("  rsrc = 0x%x,", rsrc);
2379                                 printf ("  rdst = 0x%x\n", rdst);
2380                               }
2381                             SYNTAX("adc %1%S1, %0");
2382 #line 474 "/work/sources/gcc/current/opcodes/rx-decode.opc"
2383                             ID(adc); SPm(ss, rsrc, 2); DR(rdst); F("OSZC");
2384
2385                           /*----------------------------------------------------------------------*/
2386                           /* ADD                                                                        */
2387
2388                           }
2389                         break;
2390                     }
2391                   break;
2392                 case 0x04:
2393                     GETBYTE ();
2394                     switch (op[3] & 0x00)
2395                     {
2396                       case 0x00:
2397                         goto op_semantics_8;
2398                         break;
2399                     }
2400                   break;
2401                 case 0x05:
2402                     GETBYTE ();
2403                     switch (op[3] & 0x00)
2404                     {
2405                       case 0x00:
2406                         goto op_semantics_9;
2407                         break;
2408                     }
2409                   break;
2410                 case 0x06:
2411                     GETBYTE ();
2412                     switch (op[3] & 0x00)
2413                     {
2414                       case 0x00:
2415                         goto op_semantics_10;
2416                         break;
2417                     }
2418                   break;
2419                 case 0x07:
2420                     GETBYTE ();
2421                     switch (op[3] & 0x00)
2422                     {
2423                       case 0x00:
2424                         goto op_semantics_11;
2425                         break;
2426                     }
2427                   break;
2428                 case 0x08:
2429                     GETBYTE ();
2430                     switch (op[3] & 0x00)
2431                     {
2432                       case 0x00:
2433                         goto op_semantics_12;
2434                         break;
2435                     }
2436                   break;
2437                 case 0x09:
2438                     GETBYTE ();
2439                     switch (op[3] & 0x00)
2440                     {
2441                       case 0x00:
2442                         goto op_semantics_13;
2443                         break;
2444                     }
2445                   break;
2446                 case 0x0c:
2447                     GETBYTE ();
2448                     switch (op[3] & 0x00)
2449                     {
2450                       case 0x00:
2451                         goto op_semantics_14;
2452                         break;
2453                     }
2454                   break;
2455                 case 0x0d:
2456                     GETBYTE ();
2457                     switch (op[3] & 0x00)
2458                     {
2459                       case 0x00:
2460                         goto op_semantics_15;
2461                         break;
2462                     }
2463                   break;
2464                 case 0x10:
2465                     GETBYTE ();
2466                     switch (op[3] & 0x00)
2467                     {
2468                       case 0x00:
2469                         goto op_semantics_16;
2470                         break;
2471                     }
2472                   break;
2473                 case 0x11:
2474                     GETBYTE ();
2475                     switch (op[3] & 0x00)
2476                     {
2477                       case 0x00:
2478                         goto op_semantics_17;
2479                         break;
2480                     }
2481                   break;
2482                 default: UNSUPPORTED(); break;
2483               }
2484             break;
2485           case 0xa1:
2486               GETBYTE ();
2487               switch (op[2] & 0xff)
2488               {
2489                 case 0x00:
2490                     GETBYTE ();
2491                     switch (op[3] & 0x00)
2492                     {
2493                       case 0x00:
2494                         goto op_semantics_7;
2495                         break;
2496                     }
2497                   break;
2498                 case 0x02:
2499                     GETBYTE ();
2500                     switch (op[3] & 0x00)
2501                     {
2502                       case 0x00:
2503                         goto op_semantics_18;
2504                         break;
2505                     }
2506                   break;
2507                 case 0x04:
2508                     GETBYTE ();
2509                     switch (op[3] & 0x00)
2510                     {
2511                       case 0x00:
2512                         goto op_semantics_8;
2513                         break;
2514                     }
2515                   break;
2516                 case 0x05:
2517                     GETBYTE ();
2518                     switch (op[3] & 0x00)
2519                     {
2520                       case 0x00:
2521                         goto op_semantics_9;
2522                         break;
2523                     }
2524                   break;
2525                 case 0x06:
2526                     GETBYTE ();
2527                     switch (op[3] & 0x00)
2528                     {
2529                       case 0x00:
2530                         goto op_semantics_10;
2531                         break;
2532                     }
2533                   break;
2534                 case 0x07:
2535                     GETBYTE ();
2536                     switch (op[3] & 0x00)
2537                     {
2538                       case 0x00:
2539                         goto op_semantics_11;
2540                         break;
2541                     }
2542                   break;
2543                 case 0x08:
2544                     GETBYTE ();
2545                     switch (op[3] & 0x00)
2546                     {
2547                       case 0x00:
2548                         goto op_semantics_12;
2549                         break;
2550                     }
2551                   break;
2552                 case 0x09:
2553                     GETBYTE ();
2554                     switch (op[3] & 0x00)
2555                     {
2556                       case 0x00:
2557                         goto op_semantics_13;
2558                         break;
2559                     }
2560                   break;
2561                 case 0x0c:
2562                     GETBYTE ();
2563                     switch (op[3] & 0x00)
2564                     {
2565                       case 0x00:
2566                         goto op_semantics_14;
2567                         break;
2568                     }
2569                   break;
2570                 case 0x0d:
2571                     GETBYTE ();
2572                     switch (op[3] & 0x00)
2573                     {
2574                       case 0x00:
2575                         goto op_semantics_15;
2576                         break;
2577                     }
2578                   break;
2579                 case 0x10:
2580                     GETBYTE ();
2581                     switch (op[3] & 0x00)
2582                     {
2583                       case 0x00:
2584                         goto op_semantics_16;
2585                         break;
2586                     }
2587                   break;
2588                 case 0x11:
2589                     GETBYTE ();
2590                     switch (op[3] & 0x00)
2591                     {
2592                       case 0x00:
2593                         goto op_semantics_17;
2594                         break;
2595                     }
2596                   break;
2597                 default: UNSUPPORTED(); break;
2598               }
2599             break;
2600           case 0xa2:
2601               GETBYTE ();
2602               switch (op[2] & 0xff)
2603               {
2604                 case 0x00:
2605                     GETBYTE ();
2606                     switch (op[3] & 0x00)
2607                     {
2608                       case 0x00:
2609                         goto op_semantics_7;
2610                         break;
2611                     }
2612                   break;
2613                 case 0x02:
2614                     GETBYTE ();
2615                     switch (op[3] & 0x00)
2616                     {
2617                       case 0x00:
2618                         goto op_semantics_18;
2619                         break;
2620                     }
2621                   break;
2622                 case 0x04:
2623                     GETBYTE ();
2624                     switch (op[3] & 0x00)
2625                     {
2626                       case 0x00:
2627                         goto op_semantics_8;
2628                         break;
2629                     }
2630                   break;
2631                 case 0x05:
2632                     GETBYTE ();
2633                     switch (op[3] & 0x00)
2634                     {
2635                       case 0x00:
2636                         goto op_semantics_9;
2637                         break;
2638                     }
2639                   break;
2640                 case 0x06:
2641                     GETBYTE ();
2642                     switch (op[3] & 0x00)
2643                     {
2644                       case 0x00:
2645                         goto op_semantics_10;
2646                         break;
2647                     }
2648                   break;
2649                 case 0x07:
2650                     GETBYTE ();
2651                     switch (op[3] & 0x00)
2652                     {
2653                       case 0x00:
2654                         goto op_semantics_11;
2655                         break;
2656                     }
2657                   break;
2658                 case 0x08:
2659                     GETBYTE ();
2660                     switch (op[3] & 0x00)
2661                     {
2662                       case 0x00:
2663                         goto op_semantics_12;
2664                         break;
2665                     }
2666                   break;
2667                 case 0x09:
2668                     GETBYTE ();
2669                     switch (op[3] & 0x00)
2670                     {
2671                       case 0x00:
2672                         goto op_semantics_13;
2673                         break;
2674                     }
2675                   break;
2676                 case 0x0c:
2677                     GETBYTE ();
2678                     switch (op[3] & 0x00)
2679                     {
2680                       case 0x00:
2681                         goto op_semantics_14;
2682                         break;
2683                     }
2684                   break;
2685                 case 0x0d:
2686                     GETBYTE ();
2687                     switch (op[3] & 0x00)
2688                     {
2689                       case 0x00:
2690                         goto op_semantics_15;
2691                         break;
2692                     }
2693                   break;
2694                 case 0x10:
2695                     GETBYTE ();
2696                     switch (op[3] & 0x00)
2697                     {
2698                       case 0x00:
2699                         goto op_semantics_16;
2700                         break;
2701                     }
2702                   break;
2703                 case 0x11:
2704                     GETBYTE ();
2705                     switch (op[3] & 0x00)
2706                     {
2707                       case 0x00:
2708                         goto op_semantics_17;
2709                         break;
2710                     }
2711                   break;
2712                 default: UNSUPPORTED(); break;
2713               }
2714             break;
2715           case 0xa3:
2716               GETBYTE ();
2717               switch (op[2] & 0xff)
2718               {
2719                 case 0x00:
2720                     GETBYTE ();
2721                     switch (op[3] & 0x00)
2722                     {
2723                       case 0x00:
2724                         goto op_semantics_7;
2725                         break;
2726                     }
2727                   break;
2728                 case 0x02:
2729                     GETBYTE ();
2730                     switch (op[3] & 0x00)
2731                     {
2732                       case 0x00:
2733                         goto op_semantics_18;
2734                         break;
2735                     }
2736                   break;
2737                 case 0x04:
2738                     GETBYTE ();
2739                     switch (op[3] & 0x00)
2740                     {
2741                       case 0x00:
2742                         goto op_semantics_8;
2743                         break;
2744                     }
2745                   break;
2746                 case 0x05:
2747                     GETBYTE ();
2748                     switch (op[3] & 0x00)
2749                     {
2750                       case 0x00:
2751                         goto op_semantics_9;
2752                         break;
2753                     }
2754                   break;
2755                 case 0x06:
2756                     GETBYTE ();
2757                     switch (op[3] & 0x00)
2758                     {
2759                       case 0x00:
2760                         goto op_semantics_10;
2761                         break;
2762                     }
2763                   break;
2764                 case 0x07:
2765                     GETBYTE ();
2766                     switch (op[3] & 0x00)
2767                     {
2768                       case 0x00:
2769                         goto op_semantics_11;
2770                         break;
2771                     }
2772                   break;
2773                 case 0x08:
2774                     GETBYTE ();
2775                     switch (op[3] & 0x00)
2776                     {
2777                       case 0x00:
2778                         goto op_semantics_12;
2779                         break;
2780                     }
2781                   break;
2782                 case 0x09:
2783                     GETBYTE ();
2784                     switch (op[3] & 0x00)
2785                     {
2786                       case 0x00:
2787                         goto op_semantics_13;
2788                         break;
2789                     }
2790                   break;
2791                 case 0x0c:
2792                     GETBYTE ();
2793                     switch (op[3] & 0x00)
2794                     {
2795                       case 0x00:
2796                         goto op_semantics_14;
2797                         break;
2798                     }
2799                   break;
2800                 case 0x0d:
2801                     GETBYTE ();
2802                     switch (op[3] & 0x00)
2803                     {
2804                       case 0x00:
2805                         goto op_semantics_15;
2806                         break;
2807                     }
2808                   break;
2809                 case 0x10:
2810                     GETBYTE ();
2811                     switch (op[3] & 0x00)
2812                     {
2813                       case 0x00:
2814                         goto op_semantics_16;
2815                         break;
2816                     }
2817                   break;
2818                 case 0x11:
2819                     GETBYTE ();
2820                     switch (op[3] & 0x00)
2821                     {
2822                       case 0x00:
2823                         goto op_semantics_17;
2824                         break;
2825                     }
2826                   break;
2827                 default: UNSUPPORTED(); break;
2828               }
2829             break;
2830           case 0xc0:
2831               GETBYTE ();
2832               switch (op[2] & 0x00)
2833               {
2834                 case 0x00:
2835                   goto op_semantics_1;
2836                   break;
2837               }
2838             break;
2839           case 0xc1:
2840               GETBYTE ();
2841               switch (op[2] & 0x00)
2842               {
2843                 case 0x00:
2844                   goto op_semantics_1;
2845                   break;
2846               }
2847             break;
2848           case 0xc2:
2849               GETBYTE ();
2850               switch (op[2] & 0x00)
2851               {
2852                 case 0x00:
2853                   goto op_semantics_1;
2854                   break;
2855               }
2856             break;
2857           case 0xc3:
2858               GETBYTE ();
2859               switch (op[2] & 0x00)
2860               {
2861                 case 0x00:
2862                   goto op_semantics_1;
2863                   break;
2864               }
2865             break;
2866           case 0xc4:
2867               GETBYTE ();
2868               switch (op[2] & 0x00)
2869               {
2870                 case 0x00:
2871                   goto op_semantics_2;
2872                   break;
2873               }
2874             break;
2875           case 0xc5:
2876               GETBYTE ();
2877               switch (op[2] & 0x00)
2878               {
2879                 case 0x00:
2880                   goto op_semantics_2;
2881                   break;
2882               }
2883             break;
2884           case 0xc6:
2885               GETBYTE ();
2886               switch (op[2] & 0x00)
2887               {
2888                 case 0x00:
2889                   goto op_semantics_2;
2890                   break;
2891               }
2892             break;
2893           case 0xc7:
2894               GETBYTE ();
2895               switch (op[2] & 0x00)
2896               {
2897                 case 0x00:
2898                   goto op_semantics_2;
2899                   break;
2900               }
2901             break;
2902           case 0xc8:
2903               GETBYTE ();
2904               switch (op[2] & 0x00)
2905               {
2906                 case 0x00:
2907                   goto op_semantics_3;
2908                   break;
2909               }
2910             break;
2911           case 0xc9:
2912               GETBYTE ();
2913               switch (op[2] & 0x00)
2914               {
2915                 case 0x00:
2916                   goto op_semantics_3;
2917                   break;
2918               }
2919             break;
2920           case 0xca:
2921               GETBYTE ();
2922               switch (op[2] & 0x00)
2923               {
2924                 case 0x00:
2925                   goto op_semantics_3;
2926                   break;
2927               }
2928             break;
2929           case 0xcb:
2930               GETBYTE ();
2931               switch (op[2] & 0x00)
2932               {
2933                 case 0x00:
2934                   goto op_semantics_3;
2935                   break;
2936               }
2937             break;
2938           case 0xcc:
2939               GETBYTE ();
2940               switch (op[2] & 0x00)
2941               {
2942                 case 0x00:
2943                   goto op_semantics_4;
2944                   break;
2945               }
2946             break;
2947           case 0xcd:
2948               GETBYTE ();
2949               switch (op[2] & 0x00)
2950               {
2951                 case 0x00:
2952                   goto op_semantics_4;
2953                   break;
2954               }
2955             break;
2956           case 0xce:
2957               GETBYTE ();
2958               switch (op[2] & 0x00)
2959               {
2960                 case 0x00:
2961                   goto op_semantics_4;
2962                   break;
2963               }
2964             break;
2965           case 0xcf:
2966               GETBYTE ();
2967               switch (op[2] & 0x00)
2968               {
2969                 case 0x00:
2970                   goto op_semantics_4;
2971                   break;
2972               }
2973             break;
2974           case 0xd0:
2975               GETBYTE ();
2976               switch (op[2] & 0x00)
2977               {
2978                 case 0x00:
2979                   goto op_semantics_5;
2980                   break;
2981               }
2982             break;
2983           case 0xd1:
2984               GETBYTE ();
2985               switch (op[2] & 0x00)
2986               {
2987                 case 0x00:
2988                   goto op_semantics_5;
2989                   break;
2990               }
2991             break;
2992           case 0xd2:
2993               GETBYTE ();
2994               switch (op[2] & 0x00)
2995               {
2996                 case 0x00:
2997                   goto op_semantics_5;
2998                   break;
2999               }
3000             break;
3001           case 0xd3:
3002               GETBYTE ();
3003               switch (op[2] & 0x00)
3004               {
3005                 case 0x00:
3006                   goto op_semantics_5;
3007                   break;
3008               }
3009             break;
3010           case 0xd4:
3011               GETBYTE ();
3012               switch (op[2] & 0x00)
3013               {
3014                 case 0x00:
3015                   goto op_semantics_6;
3016                   break;
3017               }
3018             break;
3019           case 0xd5:
3020               GETBYTE ();
3021               switch (op[2] & 0x00)
3022               {
3023                 case 0x00:
3024                   goto op_semantics_6;
3025                   break;
3026               }
3027             break;
3028           case 0xd6:
3029               GETBYTE ();
3030               switch (op[2] & 0x00)
3031               {
3032                 case 0x00:
3033                   goto op_semantics_6;
3034                   break;
3035               }
3036             break;
3037           case 0xd7:
3038               GETBYTE ();
3039               switch (op[2] & 0x00)
3040               {
3041                 case 0x00:
3042                   goto op_semantics_6;
3043                   break;
3044               }
3045             break;
3046           case 0xe0:
3047               GETBYTE ();
3048               switch (op[2] & 0xff)
3049               {
3050                 case 0x00:
3051                     GETBYTE ();
3052                     switch (op[3] & 0x00)
3053                     {
3054                       case 0x00:
3055                         goto op_semantics_7;
3056                         break;
3057                     }
3058                   break;
3059                 case 0x04:
3060                     GETBYTE ();
3061                     switch (op[3] & 0x00)
3062                     {
3063                       case 0x00:
3064                         goto op_semantics_8;
3065                         break;
3066                     }
3067                   break;
3068                 case 0x05:
3069                     GETBYTE ();
3070                     switch (op[3] & 0x00)
3071                     {
3072                       case 0x00:
3073                         goto op_semantics_9;
3074                         break;
3075                     }
3076                   break;
3077                 case 0x06:
3078                     GETBYTE ();
3079                     switch (op[3] & 0x00)
3080                     {
3081                       case 0x00:
3082                         goto op_semantics_10;
3083                         break;
3084                     }
3085                   break;
3086                 case 0x07:
3087                     GETBYTE ();
3088                     switch (op[3] & 0x00)
3089                     {
3090                       case 0x00:
3091                         goto op_semantics_11;
3092                         break;
3093                     }
3094                   break;
3095                 case 0x08:
3096                     GETBYTE ();
3097                     switch (op[3] & 0x00)
3098                     {
3099                       case 0x00:
3100                         goto op_semantics_12;
3101                         break;
3102                     }
3103                   break;
3104                 case 0x09:
3105                     GETBYTE ();
3106                     switch (op[3] & 0x00)
3107                     {
3108                       case 0x00:
3109                         goto op_semantics_13;
3110                         break;
3111                     }
3112                   break;
3113                 case 0x0c:
3114                     GETBYTE ();
3115                     switch (op[3] & 0x00)
3116                     {
3117                       case 0x00:
3118                         goto op_semantics_14;
3119                         break;
3120                     }
3121                   break;
3122                 case 0x0d:
3123                     GETBYTE ();
3124                     switch (op[3] & 0x00)
3125                     {
3126                       case 0x00:
3127                         goto op_semantics_15;
3128                         break;
3129                     }
3130                   break;
3131                 case 0x10:
3132                     GETBYTE ();
3133                     switch (op[3] & 0x00)
3134                     {
3135                       case 0x00:
3136                         goto op_semantics_16;
3137                         break;
3138                     }
3139                   break;
3140                 case 0x11:
3141                     GETBYTE ();
3142                     switch (op[3] & 0x00)
3143                     {
3144                       case 0x00:
3145                         goto op_semantics_17;
3146                         break;
3147                     }
3148                   break;
3149                 default: UNSUPPORTED(); break;
3150               }
3151             break;
3152           case 0xe1:
3153               GETBYTE ();
3154               switch (op[2] & 0xff)
3155               {
3156                 case 0x00:
3157                     GETBYTE ();
3158                     switch (op[3] & 0x00)
3159                     {
3160                       case 0x00:
3161                         goto op_semantics_7;
3162                         break;
3163                     }
3164                   break;
3165                 case 0x04:
3166                     GETBYTE ();
3167                     switch (op[3] & 0x00)
3168                     {
3169                       case 0x00:
3170                         goto op_semantics_8;
3171                         break;
3172                     }
3173                   break;
3174                 case 0x05:
3175                     GETBYTE ();
3176                     switch (op[3] & 0x00)
3177                     {
3178                       case 0x00:
3179                         goto op_semantics_9;
3180                         break;
3181                     }
3182                   break;
3183                 case 0x06:
3184                     GETBYTE ();
3185                     switch (op[3] & 0x00)
3186                     {
3187                       case 0x00:
3188                         goto op_semantics_10;
3189                         break;
3190                     }
3191                   break;
3192                 case 0x07:
3193                     GETBYTE ();
3194                     switch (op[3] & 0x00)
3195                     {
3196                       case 0x00:
3197                         goto op_semantics_11;
3198                         break;
3199                     }
3200                   break;
3201                 case 0x08:
3202                     GETBYTE ();
3203                     switch (op[3] & 0x00)
3204                     {
3205                       case 0x00:
3206                         goto op_semantics_12;
3207                         break;
3208                     }
3209                   break;
3210                 case 0x09:
3211                     GETBYTE ();
3212                     switch (op[3] & 0x00)
3213                     {
3214                       case 0x00:
3215                         goto op_semantics_13;
3216                         break;
3217                     }
3218                   break;
3219                 case 0x0c:
3220                     GETBYTE ();
3221                     switch (op[3] & 0x00)
3222                     {
3223                       case 0x00:
3224                         goto op_semantics_14;
3225                         break;
3226                     }
3227                   break;
3228                 case 0x0d:
3229                     GETBYTE ();
3230                     switch (op[3] & 0x00)
3231                     {
3232                       case 0x00:
3233                         goto op_semantics_15;
3234                         break;
3235                     }
3236                   break;
3237                 case 0x10:
3238                     GETBYTE ();
3239                     switch (op[3] & 0x00)
3240                     {
3241                       case 0x00:
3242                         goto op_semantics_16;
3243                         break;
3244                     }
3245                   break;
3246                 case 0x11:
3247                     GETBYTE ();
3248                     switch (op[3] & 0x00)
3249                     {
3250                       case 0x00:
3251                         goto op_semantics_17;
3252                         break;
3253                     }
3254                   break;
3255                 default: UNSUPPORTED(); break;
3256               }
3257             break;
3258           case 0xe2:
3259               GETBYTE ();
3260               switch (op[2] & 0xff)
3261               {
3262                 case 0x00:
3263                     GETBYTE ();
3264                     switch (op[3] & 0x00)
3265                     {
3266                       case 0x00:
3267                         goto op_semantics_7;
3268                         break;
3269                     }
3270                   break;
3271                 case 0x04:
3272                     GETBYTE ();
3273                     switch (op[3] & 0x00)
3274                     {
3275                       case 0x00:
3276                         goto op_semantics_8;
3277                         break;
3278                     }
3279                   break;
3280                 case 0x05:
3281                     GETBYTE ();
3282                     switch (op[3] & 0x00)
3283                     {
3284                       case 0x00:
3285                         goto op_semantics_9;
3286                         break;
3287                     }
3288                   break;
3289                 case 0x06:
3290                     GETBYTE ();
3291                     switch (op[3] & 0x00)
3292                     {
3293                       case 0x00:
3294                         goto op_semantics_10;
3295                         break;
3296                     }
3297                   break;
3298                 case 0x07:
3299                     GETBYTE ();
3300                     switch (op[3] & 0x00)
3301                     {
3302                       case 0x00:
3303                         goto op_semantics_11;
3304                         break;
3305                     }
3306                   break;
3307                 case 0x08:
3308                     GETBYTE ();
3309                     switch (op[3] & 0x00)
3310                     {
3311                       case 0x00:
3312                         goto op_semantics_12;
3313                         break;
3314                     }
3315                   break;
3316                 case 0x09:
3317                     GETBYTE ();
3318                     switch (op[3] & 0x00)
3319                     {
3320                       case 0x00:
3321                         goto op_semantics_13;
3322                         break;
3323                     }
3324                   break;
3325                 case 0x0c:
3326                     GETBYTE ();
3327                     switch (op[3] & 0x00)
3328                     {
3329                       case 0x00:
3330                         goto op_semantics_14;
3331                         break;
3332                     }
3333                   break;
3334                 case 0x0d:
3335                     GETBYTE ();
3336                     switch (op[3] & 0x00)
3337                     {
3338                       case 0x00:
3339                         goto op_semantics_15;
3340                         break;
3341                     }
3342                   break;
3343                 case 0x10:
3344                     GETBYTE ();
3345                     switch (op[3] & 0x00)
3346                     {
3347                       case 0x00:
3348                         goto op_semantics_16;
3349                         break;
3350                     }
3351                   break;
3352                 case 0x11:
3353                     GETBYTE ();
3354                     switch (op[3] & 0x00)
3355                     {
3356                       case 0x00:
3357                         goto op_semantics_17;
3358                         break;
3359                     }
3360                   break;
3361                 default: UNSUPPORTED(); break;
3362               }
3363             break;
3364           case 0xe3:
3365               GETBYTE ();
3366               switch (op[2] & 0xff)
3367               {
3368                 case 0x00:
3369                     GETBYTE ();
3370                     switch (op[3] & 0x00)
3371                     {
3372                       case 0x00:
3373                         goto op_semantics_7;
3374                         break;
3375                     }
3376                   break;
3377                 case 0x04:
3378                     GETBYTE ();
3379                     switch (op[3] & 0x00)
3380                     {
3381                       case 0x00:
3382                         goto op_semantics_8;
3383                         break;
3384                     }
3385                   break;
3386                 case 0x05:
3387                     GETBYTE ();
3388                     switch (op[3] & 0x00)
3389                     {
3390                       case 0x00:
3391                         goto op_semantics_9;
3392                         break;
3393                     }
3394                   break;
3395                 case 0x06:
3396                     GETBYTE ();
3397                     switch (op[3] & 0x00)
3398                     {
3399                       case 0x00:
3400                         goto op_semantics_10;
3401                         break;
3402                     }
3403                   break;
3404                 case 0x07:
3405                     GETBYTE ();
3406                     switch (op[3] & 0x00)
3407                     {
3408                       case 0x00:
3409                         goto op_semantics_11;
3410                         break;
3411                     }
3412                   break;
3413                 case 0x08:
3414                     GETBYTE ();
3415                     switch (op[3] & 0x00)
3416                     {
3417                       case 0x00:
3418                         goto op_semantics_12;
3419                         break;
3420                     }
3421                   break;
3422                 case 0x09:
3423                     GETBYTE ();
3424                     switch (op[3] & 0x00)
3425                     {
3426                       case 0x00:
3427                         goto op_semantics_13;
3428                         break;
3429                     }
3430                   break;
3431                 case 0x0c:
3432                     GETBYTE ();
3433                     switch (op[3] & 0x00)
3434                     {
3435                       case 0x00:
3436                         goto op_semantics_14;
3437                         break;
3438                     }
3439                   break;
3440                 case 0x0d:
3441                     GETBYTE ();
3442                     switch (op[3] & 0x00)
3443                     {
3444                       case 0x00:
3445                         goto op_semantics_15;
3446                         break;
3447                     }
3448                   break;
3449                 case 0x10:
3450                     GETBYTE ();
3451                     switch (op[3] & 0x00)
3452                     {
3453                       case 0x00:
3454                         goto op_semantics_16;
3455                         break;
3456                     }
3457                   break;
3458                 case 0x11:
3459                     GETBYTE ();
3460                     switch (op[3] & 0x00)
3461                     {
3462                       case 0x00:
3463                         goto op_semantics_17;
3464                         break;
3465                     }
3466                   break;
3467                 default: UNSUPPORTED(); break;
3468               }
3469             break;
3470           default: UNSUPPORTED(); break;
3471         }
3472       break;
3473     case 0x08:
3474     case 0x09:
3475     case 0x0a:
3476     case 0x0b:
3477     case 0x0c:
3478     case 0x0d:
3479     case 0x0e:
3480     case 0x0f:
3481         {
3482           /** 0000 1dsp                 bra.s   %a0 */
3483 #line 708 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3484           int dsp AU = op[0] & 0x07;
3485           if (trace)
3486             {
3487               printf ("\033[33m%s\033[0m  %02x\n",
3488                      "/** 0000 1dsp                     bra.s   %a0 */",
3489                      op[0]);
3490               printf ("  dsp = 0x%x\n", dsp);
3491             }
3492           SYNTAX("bra.s %a0");
3493 #line 709 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3494           ID(branch); Scc(RXC_always); DC(pc + dsp3map[dsp]);
3495
3496         }
3497       break;
3498     case 0x10:
3499     case 0x11:
3500     case 0x12:
3501     case 0x13:
3502     case 0x14:
3503     case 0x15:
3504     case 0x16:
3505     case 0x17:
3506     case 0x18:
3507     case 0x19:
3508     case 0x1a:
3509     case 0x1b:
3510     case 0x1c:
3511     case 0x1d:
3512     case 0x1e:
3513     case 0x1f:
3514         {
3515           /** 0001 n dsp                        b%1.s   %a0 */
3516 #line 698 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3517           int n AU = (op[0] >> 3) & 0x01;
3518 #line 698 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3519           int dsp AU = op[0] & 0x07;
3520           if (trace)
3521             {
3522               printf ("\033[33m%s\033[0m  %02x\n",
3523                      "/** 0001 n dsp                    b%1.s   %a0 */",
3524                      op[0]);
3525               printf ("  n = 0x%x,", n);
3526               printf ("  dsp = 0x%x\n", dsp);
3527             }
3528           SYNTAX("b%1.s %a0");
3529 #line 699 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3530           ID(branch); Scc(n); DC(pc + dsp3map[dsp]);
3531
3532         }
3533       break;
3534     case 0x20:
3535     case 0x21:
3536     case 0x22:
3537     case 0x23:
3538     case 0x24:
3539     case 0x25:
3540     case 0x26:
3541     case 0x27:
3542     case 0x28:
3543     case 0x29:
3544     case 0x2a:
3545     case 0x2b:
3546     case 0x2c:
3547     case 0x2d:
3548     case 0x2f:
3549         {
3550           /** 0010 cond                 b%1.b   %a0 */
3551 #line 701 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3552           int cond AU = op[0] & 0x0f;
3553           if (trace)
3554             {
3555               printf ("\033[33m%s\033[0m  %02x\n",
3556                      "/** 0010 cond                     b%1.b   %a0 */",
3557                      op[0]);
3558               printf ("  cond = 0x%x\n", cond);
3559             }
3560           SYNTAX("b%1.b %a0");
3561 #line 702 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3562           ID(branch); Scc(cond); DC(pc + IMMex (1));
3563
3564         }
3565       break;
3566     case 0x2e:
3567         {
3568           /** 0010 1110                 bra.b   %a0 */
3569           if (trace)
3570             {
3571               printf ("\033[33m%s\033[0m  %02x\n",
3572                      "/** 0010 1110                     bra.b   %a0 */",
3573                      op[0]);
3574             }
3575           SYNTAX("bra.b %a0");
3576 #line 712 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3577           ID(branch); Scc(RXC_always); DC(pc + IMMex(1));
3578
3579         }
3580       break;
3581     case 0x38:
3582         {
3583           /** 0011 1000                 bra.w   %a0 */
3584           if (trace)
3585             {
3586               printf ("\033[33m%s\033[0m  %02x\n",
3587                      "/** 0011 1000                     bra.w   %a0 */",
3588                      op[0]);
3589             }
3590           SYNTAX("bra.w %a0");
3591 #line 715 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3592           ID(branch); Scc(RXC_always); DC(pc + IMMex(2));
3593
3594         }
3595       break;
3596     case 0x39:
3597         {
3598           /** 0011 1001                 bsr.w   %a0 */
3599           if (trace)
3600             {
3601               printf ("\033[33m%s\033[0m  %02x\n",
3602                      "/** 0011 1001                     bsr.w   %a0 */",
3603                      op[0]);
3604             }
3605           SYNTAX("bsr.w %a0");
3606 #line 731 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3607           ID(jsr); DC(pc + IMMex(2));
3608
3609         }
3610       break;
3611     case 0x3a:
3612     case 0x3b:
3613         {
3614           /** 0011 101c                 b%1.w   %a0 */
3615 #line 704 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3616           int c AU = op[0] & 0x01;
3617           if (trace)
3618             {
3619               printf ("\033[33m%s\033[0m  %02x\n",
3620                      "/** 0011 101c                     b%1.w   %a0 */",
3621                      op[0]);
3622               printf ("  c = 0x%x\n", c);
3623             }
3624           SYNTAX("b%1.w %a0");
3625 #line 705 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3626           ID(branch); Scc(c); DC(pc + IMMex (2));
3627
3628
3629         }
3630       break;
3631     case 0x3c:
3632         GETBYTE ();
3633         switch (op[1] & 0x00)
3634         {
3635           case 0x00:
3636             op_semantics_19:
3637               {
3638                 /** 0011 11sz d dst sppp                mov%s   #%1, %0 */
3639 #line 294 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3640                 int sz AU = op[0] & 0x03;
3641 #line 294 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3642                 int d AU = (op[1] >> 7) & 0x01;
3643 #line 294 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3644                 int dst AU = (op[1] >> 4) & 0x07;
3645 #line 294 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3646                 int sppp AU = op[1] & 0x0f;
3647                 if (trace)
3648                   {
3649                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3650                            "/** 0011 11sz d dst sppp            mov%s   #%1, %0 */",
3651                            op[0], op[1]);
3652                     printf ("  sz = 0x%x,", sz);
3653                     printf ("  d = 0x%x,", d);
3654                     printf ("  dst = 0x%x,", dst);
3655                     printf ("  sppp = 0x%x\n", sppp);
3656                   }
3657                 SYNTAX("mov%s   #%1, %0");
3658 #line 295 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3659                 ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F("----");
3660
3661               }
3662             break;
3663         }
3664       break;
3665     case 0x3d:
3666         GETBYTE ();
3667         switch (op[1] & 0x00)
3668         {
3669           case 0x00:
3670             goto op_semantics_19;
3671             break;
3672         }
3673       break;
3674     case 0x3e:
3675         GETBYTE ();
3676         switch (op[1] & 0x00)
3677         {
3678           case 0x00:
3679             goto op_semantics_19;
3680             break;
3681         }
3682       break;
3683     case 0x3f:
3684         GETBYTE ();
3685         switch (op[1] & 0x00)
3686         {
3687           case 0x00:
3688               {
3689                 /** 0011 1111 rega regb         rtsd    #%1, %2-%0 */
3690 #line 383 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3691                 int rega AU = (op[1] >> 4) & 0x0f;
3692 #line 383 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3693                 int regb AU = op[1] & 0x0f;
3694                 if (trace)
3695                   {
3696                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3697                            "/** 0011 1111 rega regb             rtsd    #%1, %2-%0 */",
3698                            op[0], op[1]);
3699                     printf ("  rega = 0x%x,", rega);
3700                     printf ("  regb = 0x%x\n", regb);
3701                   }
3702                 SYNTAX("rtsd    #%1, %2-%0");
3703 #line 384 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3704                 ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb);
3705
3706               /*----------------------------------------------------------------------*/
3707               /* AND                                                                    */
3708
3709               }
3710             break;
3711         }
3712       break;
3713     case 0x40:
3714         GETBYTE ();
3715         switch (op[1] & 0x00)
3716         {
3717           case 0x00:
3718             op_semantics_20:
3719               {
3720                 /** 0100 00ss rsrc rdst                 sub     %2%S2, %1 */
3721 #line 518 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3722                 int ss AU = op[0] & 0x03;
3723 #line 518 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3724                 int rsrc AU = (op[1] >> 4) & 0x0f;
3725 #line 518 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3726                 int rdst AU = op[1] & 0x0f;
3727                 if (trace)
3728                   {
3729                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3730                            "/** 0100 00ss rsrc rdst                     sub     %2%S2, %1 */",
3731                            op[0], op[1]);
3732                     printf ("  ss = 0x%x,", ss);
3733                     printf ("  rsrc = 0x%x,", rsrc);
3734                     printf ("  rdst = 0x%x\n", rdst);
3735                   }
3736                 SYNTAX("sub     %2%S2, %1");
3737 #line 519 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3738                 ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F("OSZC");
3739
3740               }
3741             break;
3742         }
3743       break;
3744     case 0x41:
3745         GETBYTE ();
3746         switch (op[1] & 0x00)
3747         {
3748           case 0x00:
3749             goto op_semantics_20;
3750             break;
3751         }
3752       break;
3753     case 0x42:
3754         GETBYTE ();
3755         switch (op[1] & 0x00)
3756         {
3757           case 0x00:
3758             goto op_semantics_20;
3759             break;
3760         }
3761       break;
3762     case 0x43:
3763         GETBYTE ();
3764         switch (op[1] & 0x00)
3765         {
3766           case 0x00:
3767             goto op_semantics_20;
3768             break;
3769         }
3770       break;
3771     case 0x44:
3772         GETBYTE ();
3773         switch (op[1] & 0x00)
3774         {
3775           case 0x00:
3776             op_semantics_21:
3777               {
3778                 /** 0100 01ss rsrc rdst         cmp     %2%S2, %1 */
3779 #line 506 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3780                 int ss AU = op[0] & 0x03;
3781 #line 506 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3782                 int rsrc AU = (op[1] >> 4) & 0x0f;
3783 #line 506 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3784                 int rdst AU = op[1] & 0x0f;
3785                 if (trace)
3786                   {
3787                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3788                            "/** 0100 01ss rsrc rdst             cmp     %2%S2, %1 */",
3789                            op[0], op[1]);
3790                     printf ("  ss = 0x%x,", ss);
3791                     printf ("  rsrc = 0x%x,", rsrc);
3792                     printf ("  rdst = 0x%x\n", rdst);
3793                   }
3794                 SYNTAX("cmp     %2%S2, %1");
3795 #line 507 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3796                 ID(sub); S2P(ss, rsrc); SR(rdst); F("OSZC");
3797
3798               }
3799             break;
3800         }
3801       break;
3802     case 0x45:
3803         GETBYTE ();
3804         switch (op[1] & 0x00)
3805         {
3806           case 0x00:
3807             goto op_semantics_21;
3808             break;
3809         }
3810       break;
3811     case 0x46:
3812         GETBYTE ();
3813         switch (op[1] & 0x00)
3814         {
3815           case 0x00:
3816             goto op_semantics_21;
3817             break;
3818         }
3819       break;
3820     case 0x47:
3821         GETBYTE ();
3822         switch (op[1] & 0x00)
3823         {
3824           case 0x00:
3825             goto op_semantics_21;
3826             break;
3827         }
3828       break;
3829     case 0x48:
3830         GETBYTE ();
3831         switch (op[1] & 0x00)
3832         {
3833           case 0x00:
3834             op_semantics_22:
3835               {
3836                 /** 0100 10ss rsrc rdst                 add     %1%S1, %0 */
3837 #line 482 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3838                 int ss AU = op[0] & 0x03;
3839 #line 482 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3840                 int rsrc AU = (op[1] >> 4) & 0x0f;
3841 #line 482 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3842                 int rdst AU = op[1] & 0x0f;
3843                 if (trace)
3844                   {
3845                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3846                            "/** 0100 10ss rsrc rdst                     add     %1%S1, %0 */",
3847                            op[0], op[1]);
3848                     printf ("  ss = 0x%x,", ss);
3849                     printf ("  rsrc = 0x%x,", rsrc);
3850                     printf ("  rdst = 0x%x\n", rdst);
3851                   }
3852                 SYNTAX("add     %1%S1, %0");
3853 #line 483 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3854                 ID(add); SP(ss, rsrc); DR(rdst); F("OSZC");
3855
3856               }
3857             break;
3858         }
3859       break;
3860     case 0x49:
3861         GETBYTE ();
3862         switch (op[1] & 0x00)
3863         {
3864           case 0x00:
3865             goto op_semantics_22;
3866             break;
3867         }
3868       break;
3869     case 0x4a:
3870         GETBYTE ();
3871         switch (op[1] & 0x00)
3872         {
3873           case 0x00:
3874             goto op_semantics_22;
3875             break;
3876         }
3877       break;
3878     case 0x4b:
3879         GETBYTE ();
3880         switch (op[1] & 0x00)
3881         {
3882           case 0x00:
3883             goto op_semantics_22;
3884             break;
3885         }
3886       break;
3887     case 0x4c:
3888         GETBYTE ();
3889         switch (op[1] & 0x00)
3890         {
3891           case 0x00:
3892             op_semantics_23:
3893               {
3894                 /** 0100 11ss rsrc rdst                 mul     %1%S1, %0 */
3895 #line 579 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3896                 int ss AU = op[0] & 0x03;
3897 #line 579 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3898                 int rsrc AU = (op[1] >> 4) & 0x0f;
3899 #line 579 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3900                 int rdst AU = op[1] & 0x0f;
3901                 if (trace)
3902                   {
3903                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3904                            "/** 0100 11ss rsrc rdst                     mul     %1%S1, %0 */",
3905                            op[0], op[1]);
3906                     printf ("  ss = 0x%x,", ss);
3907                     printf ("  rsrc = 0x%x,", rsrc);
3908                     printf ("  rdst = 0x%x\n", rdst);
3909                   }
3910                 SYNTAX("mul     %1%S1, %0");
3911 #line 580 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3912                 ID(mul); SP(ss, rsrc); DR(rdst); F("O---");
3913
3914               }
3915             break;
3916         }
3917       break;
3918     case 0x4d:
3919         GETBYTE ();
3920         switch (op[1] & 0x00)
3921         {
3922           case 0x00:
3923             goto op_semantics_23;
3924             break;
3925         }
3926       break;
3927     case 0x4e:
3928         GETBYTE ();
3929         switch (op[1] & 0x00)
3930         {
3931           case 0x00:
3932             goto op_semantics_23;
3933             break;
3934         }
3935       break;
3936     case 0x4f:
3937         GETBYTE ();
3938         switch (op[1] & 0x00)
3939         {
3940           case 0x00:
3941             goto op_semantics_23;
3942             break;
3943         }
3944       break;
3945     case 0x50:
3946         GETBYTE ();
3947         switch (op[1] & 0x00)
3948         {
3949           case 0x00:
3950             op_semantics_24:
3951               {
3952                 /** 0101 00ss rsrc rdst                 and     %1%S1, %0 */
3953 #line 395 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3954                 int ss AU = op[0] & 0x03;
3955 #line 395 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3956                 int rsrc AU = (op[1] >> 4) & 0x0f;
3957 #line 395 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3958                 int rdst AU = op[1] & 0x0f;
3959                 if (trace)
3960                   {
3961                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3962                            "/** 0101 00ss rsrc rdst                     and     %1%S1, %0 */",
3963                            op[0], op[1]);
3964                     printf ("  ss = 0x%x,", ss);
3965                     printf ("  rsrc = 0x%x,", rsrc);
3966                     printf ("  rdst = 0x%x\n", rdst);
3967                   }
3968                 SYNTAX("and     %1%S1, %0");
3969 #line 396 "/work/sources/gcc/current/opcodes/rx-decode.opc"
3970                 ID(and); SP(ss, rsrc); DR(rdst); F("-SZ-");
3971
3972               }
3973             break;
3974         }
3975       break;
3976     case 0x51:
3977         GETBYTE ();
3978         switch (op[1] & 0x00)
3979         {
3980           case 0x00:
3981             goto op_semantics_24;
3982             break;
3983         }
3984       break;
3985     case 0x52:
3986         GETBYTE ();
3987         switch (op[1] & 0x00)
3988         {
3989           case 0x00:
3990             goto op_semantics_24;
3991             break;
3992         }
3993       break;
3994     case 0x53:
3995         GETBYTE ();
3996         switch (op[1] & 0x00)
3997         {
3998           case 0x00:
3999             goto op_semantics_24;
4000             break;
4001         }
4002       break;
4003     case 0x54:
4004         GETBYTE ();
4005         switch (op[1] & 0x00)
4006         {
4007           case 0x00:
4008             op_semantics_25:
4009               {
4010                 /** 0101 01ss rsrc rdst                 or      %1%S1, %0 */
4011 #line 413 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4012                 int ss AU = op[0] & 0x03;
4013 #line 413 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4014                 int rsrc AU = (op[1] >> 4) & 0x0f;
4015 #line 413 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4016                 int rdst AU = op[1] & 0x0f;
4017                 if (trace)
4018                   {
4019                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4020                            "/** 0101 01ss rsrc rdst                     or      %1%S1, %0 */",
4021                            op[0], op[1]);
4022                     printf ("  ss = 0x%x,", ss);
4023                     printf ("  rsrc = 0x%x,", rsrc);
4024                     printf ("  rdst = 0x%x\n", rdst);
4025                   }
4026                 SYNTAX("or      %1%S1, %0");
4027 #line 414 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4028                 ID(or); SP(ss, rsrc); DR(rdst); F("-SZ-");
4029
4030               }
4031             break;
4032         }
4033       break;
4034     case 0x55:
4035         GETBYTE ();
4036         switch (op[1] & 0x00)
4037         {
4038           case 0x00:
4039             goto op_semantics_25;
4040             break;
4041         }
4042       break;
4043     case 0x56:
4044         GETBYTE ();
4045         switch (op[1] & 0x00)
4046         {
4047           case 0x00:
4048             goto op_semantics_25;
4049             break;
4050         }
4051       break;
4052     case 0x57:
4053         GETBYTE ();
4054         switch (op[1] & 0x00)
4055         {
4056           case 0x00:
4057             goto op_semantics_25;
4058             break;
4059         }
4060       break;
4061     case 0x58:
4062         GETBYTE ();
4063         switch (op[1] & 0x00)
4064         {
4065           case 0x00:
4066             op_semantics_26:
4067               {
4068                 /** 0101 1 s ss rsrc rdst       movu%s  %1, %0 */
4069 #line 334 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4070                 int s AU = (op[0] >> 2) & 0x01;
4071 #line 334 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4072                 int ss AU = op[0] & 0x03;
4073 #line 334 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4074                 int rsrc AU = (op[1] >> 4) & 0x0f;
4075 #line 334 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4076                 int rdst AU = op[1] & 0x0f;
4077                 if (trace)
4078                   {
4079                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4080                            "/** 0101 1 s ss rsrc rdst   movu%s  %1, %0 */",
4081                            op[0], op[1]);
4082                     printf ("  s = 0x%x,", s);
4083                     printf ("  ss = 0x%x,", ss);
4084                     printf ("  rsrc = 0x%x,", rsrc);
4085                     printf ("  rdst = 0x%x\n", rdst);
4086                   }
4087                 SYNTAX("movu%s  %1, %0");
4088 #line 335 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4089                 ID(mov); uBWL(s); SD(ss, rsrc, s); DR(rdst); F("----");
4090
4091               }
4092             break;
4093         }
4094       break;
4095     case 0x59:
4096         GETBYTE ();
4097         switch (op[1] & 0x00)
4098         {
4099           case 0x00:
4100             goto op_semantics_26;
4101             break;
4102         }
4103       break;
4104     case 0x5a:
4105         GETBYTE ();
4106         switch (op[1] & 0x00)
4107         {
4108           case 0x00:
4109             goto op_semantics_26;
4110             break;
4111         }
4112       break;
4113     case 0x5b:
4114         GETBYTE ();
4115         switch (op[1] & 0x00)
4116         {
4117           case 0x00:
4118             goto op_semantics_26;
4119             break;
4120         }
4121       break;
4122     case 0x5c:
4123         GETBYTE ();
4124         switch (op[1] & 0x00)
4125         {
4126           case 0x00:
4127             goto op_semantics_26;
4128             break;
4129         }
4130       break;
4131     case 0x5d:
4132         GETBYTE ();
4133         switch (op[1] & 0x00)
4134         {
4135           case 0x00:
4136             goto op_semantics_26;
4137             break;
4138         }
4139       break;
4140     case 0x5e:
4141         GETBYTE ();
4142         switch (op[1] & 0x00)
4143         {
4144           case 0x00:
4145             goto op_semantics_26;
4146             break;
4147         }
4148       break;
4149     case 0x5f:
4150         GETBYTE ();
4151         switch (op[1] & 0x00)
4152         {
4153           case 0x00:
4154             goto op_semantics_26;
4155             break;
4156         }
4157       break;
4158     case 0x60:
4159         GETBYTE ();
4160         switch (op[1] & 0x00)
4161         {
4162           case 0x00:
4163               {
4164                 /** 0110 0000 immm rdst                 sub     #%2, %0 */
4165 #line 515 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4166                 int immm AU = (op[1] >> 4) & 0x0f;
4167 #line 515 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4168                 int rdst AU = op[1] & 0x0f;
4169                 if (trace)
4170                   {
4171                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4172                            "/** 0110 0000 immm rdst                     sub     #%2, %0 */",
4173                            op[0], op[1]);
4174                     printf ("  immm = 0x%x,", immm);
4175                     printf ("  rdst = 0x%x\n", rdst);
4176                   }
4177                 SYNTAX("sub     #%2, %0");
4178 #line 516 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4179                 ID(sub); S2C(immm); SR(rdst); DR(rdst); F("OSZC");
4180
4181               }
4182             break;
4183         }
4184       break;
4185     case 0x61:
4186         GETBYTE ();
4187         switch (op[1] & 0x00)
4188         {
4189           case 0x00:
4190               {
4191                 /** 0110 0001 immm rdst                 cmp     #%2, %1 */
4192 #line 497 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4193                 int immm AU = (op[1] >> 4) & 0x0f;
4194 #line 497 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4195                 int rdst AU = op[1] & 0x0f;
4196                 if (trace)
4197                   {
4198                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4199                            "/** 0110 0001 immm rdst                     cmp     #%2, %1 */",
4200                            op[0], op[1]);
4201                     printf ("  immm = 0x%x,", immm);
4202                     printf ("  rdst = 0x%x\n", rdst);
4203                   }
4204                 SYNTAX("cmp     #%2, %1");
4205 #line 498 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4206                 ID(sub); S2C(immm); SR(rdst); F("OSZC");
4207
4208               }
4209             break;
4210         }
4211       break;
4212     case 0x62:
4213         GETBYTE ();
4214         switch (op[1] & 0x00)
4215         {
4216           case 0x00:
4217               {
4218                 /** 0110 0010 immm rdst                 add     #%1, %0 */
4219 #line 479 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4220                 int immm AU = (op[1] >> 4) & 0x0f;
4221 #line 479 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4222                 int rdst AU = op[1] & 0x0f;
4223                 if (trace)
4224                   {
4225                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4226                            "/** 0110 0010 immm rdst                     add     #%1, %0 */",
4227                            op[0], op[1]);
4228                     printf ("  immm = 0x%x,", immm);
4229                     printf ("  rdst = 0x%x\n", rdst);
4230                   }
4231                 SYNTAX("add     #%1, %0");
4232 #line 480 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4233                 ID(add); SC(immm); DR(rdst); F("OSZC");
4234
4235               }
4236             break;
4237         }
4238       break;
4239     case 0x63:
4240         GETBYTE ();
4241         switch (op[1] & 0x00)
4242         {
4243           case 0x00:
4244               {
4245                 /** 0110 0011 immm rdst                 mul     #%1, %0 */
4246 #line 573 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4247                 int immm AU = (op[1] >> 4) & 0x0f;
4248 #line 573 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4249                 int rdst AU = op[1] & 0x0f;
4250                 if (trace)
4251                   {
4252                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4253                            "/** 0110 0011 immm rdst                     mul     #%1, %0 */",
4254                            op[0], op[1]);
4255                     printf ("  immm = 0x%x,", immm);
4256                     printf ("  rdst = 0x%x\n", rdst);
4257                   }
4258                 SYNTAX("mul     #%1, %0");
4259 #line 574 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4260                 ID(mul); DR(rdst); SC(immm); F("O---");
4261
4262               }
4263             break;
4264         }
4265       break;
4266     case 0x64:
4267         GETBYTE ();
4268         switch (op[1] & 0x00)
4269         {
4270           case 0x00:
4271               {
4272                 /** 0110 0100 immm rdst                 and     #%1, %0 */
4273 #line 389 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4274                 int immm AU = (op[1] >> 4) & 0x0f;
4275 #line 389 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4276                 int rdst AU = op[1] & 0x0f;
4277                 if (trace)
4278                   {
4279                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4280                            "/** 0110 0100 immm rdst                     and     #%1, %0 */",
4281                            op[0], op[1]);
4282                     printf ("  immm = 0x%x,", immm);
4283                     printf ("  rdst = 0x%x\n", rdst);
4284                   }
4285                 SYNTAX("and     #%1, %0");
4286 #line 390 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4287                 ID(and); SC(immm); DR(rdst); F("-SZ-");
4288
4289               }
4290             break;
4291         }
4292       break;
4293     case 0x65:
4294         GETBYTE ();
4295         switch (op[1] & 0x00)
4296         {
4297           case 0x00:
4298               {
4299                 /** 0110 0101 immm rdst                 or      #%1, %0 */
4300 #line 407 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4301                 int immm AU = (op[1] >> 4) & 0x0f;
4302 #line 407 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4303                 int rdst AU = op[1] & 0x0f;
4304                 if (trace)
4305                   {
4306                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4307                            "/** 0110 0101 immm rdst                     or      #%1, %0 */",
4308                            op[0], op[1]);
4309                     printf ("  immm = 0x%x,", immm);
4310                     printf ("  rdst = 0x%x\n", rdst);
4311                   }
4312                 SYNTAX("or      #%1, %0");
4313 #line 408 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4314                 ID(or); SC(immm); DR(rdst); F("-SZ-");
4315
4316               }
4317             break;
4318         }
4319       break;
4320     case 0x66:
4321         GETBYTE ();
4322         switch (op[1] & 0x00)
4323         {
4324           case 0x00:
4325               {
4326                 /** 0110 0110 immm rdst         mov%s   #%1, %0 */
4327 #line 291 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4328                 int immm AU = (op[1] >> 4) & 0x0f;
4329 #line 291 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4330                 int rdst AU = op[1] & 0x0f;
4331                 if (trace)
4332                   {
4333                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4334                            "/** 0110 0110 immm rdst             mov%s   #%1, %0 */",
4335                            op[0], op[1]);
4336                     printf ("  immm = 0x%x,", immm);
4337                     printf ("  rdst = 0x%x\n", rdst);
4338                   }
4339                 SYNTAX("mov%s   #%1, %0");
4340 #line 292 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4341                 ID(mov); DR(rdst); SC(immm); F("----");
4342
4343               }
4344             break;
4345         }
4346       break;
4347     case 0x67:
4348         {
4349           /** 0110 0111                 rtsd    #%1 */
4350           if (trace)
4351             {
4352               printf ("\033[33m%s\033[0m  %02x\n",
4353                      "/** 0110 0111                     rtsd    #%1 */",
4354                      op[0]);
4355             }
4356           SYNTAX("rtsd  #%1");
4357 #line 381 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4358           ID(rtsd); SC(IMM(1) * 4);
4359
4360         }
4361       break;
4362     case 0x68:
4363         GETBYTE ();
4364         switch (op[1] & 0x00)
4365         {
4366           case 0x00:
4367             op_semantics_27:
4368               {
4369                 /** 0110 100i mmmm rdst                 shlr    #%2, %0 */
4370 #line 659 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4371                 int i AU = op[0] & 0x01;
4372 #line 659 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4373                 int mmmm AU = (op[1] >> 4) & 0x0f;
4374 #line 659 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4375                 int rdst AU = op[1] & 0x0f;
4376                 if (trace)
4377                   {
4378                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4379                            "/** 0110 100i mmmm rdst                     shlr    #%2, %0 */",
4380                            op[0], op[1]);
4381                     printf ("  i = 0x%x,", i);
4382                     printf ("  mmmm = 0x%x,", mmmm);
4383                     printf ("  rdst = 0x%x\n", rdst);
4384                   }
4385                 SYNTAX("shlr    #%2, %0");
4386 #line 660 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4387                 ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F("-SZC");
4388
4389               }
4390             break;
4391         }
4392       break;
4393     case 0x69:
4394         GETBYTE ();
4395         switch (op[1] & 0x00)
4396         {
4397           case 0x00:
4398             goto op_semantics_27;
4399             break;
4400         }
4401       break;
4402     case 0x6a:
4403         GETBYTE ();
4404         switch (op[1] & 0x00)
4405         {
4406           case 0x00:
4407             op_semantics_28:
4408               {
4409                 /** 0110 101i mmmm rdst                 shar    #%2, %0 */
4410 #line 649 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4411                 int i AU = op[0] & 0x01;
4412 #line 649 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4413                 int mmmm AU = (op[1] >> 4) & 0x0f;
4414 #line 649 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4415                 int rdst AU = op[1] & 0x0f;
4416                 if (trace)
4417                   {
4418                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4419                            "/** 0110 101i mmmm rdst                     shar    #%2, %0 */",
4420                            op[0], op[1]);
4421                     printf ("  i = 0x%x,", i);
4422                     printf ("  mmmm = 0x%x,", mmmm);
4423                     printf ("  rdst = 0x%x\n", rdst);
4424                   }
4425                 SYNTAX("shar    #%2, %0");
4426 #line 650 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4427                 ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F("0SZC");
4428
4429               }
4430             break;
4431         }
4432       break;
4433     case 0x6b:
4434         GETBYTE ();
4435         switch (op[1] & 0x00)
4436         {
4437           case 0x00:
4438             goto op_semantics_28;
4439             break;
4440         }
4441       break;
4442     case 0x6c:
4443         GETBYTE ();
4444         switch (op[1] & 0x00)
4445         {
4446           case 0x00:
4447             op_semantics_29:
4448               {
4449                 /** 0110 110i mmmm rdst                 shll    #%2, %0 */
4450 #line 639 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4451                 int i AU = op[0] & 0x01;
4452 #line 639 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4453                 int mmmm AU = (op[1] >> 4) & 0x0f;
4454 #line 639 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4455                 int rdst AU = op[1] & 0x0f;
4456                 if (trace)
4457                   {
4458                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4459                            "/** 0110 110i mmmm rdst                     shll    #%2, %0 */",
4460                            op[0], op[1]);
4461                     printf ("  i = 0x%x,", i);
4462                     printf ("  mmmm = 0x%x,", mmmm);
4463                     printf ("  rdst = 0x%x\n", rdst);
4464                   }
4465                 SYNTAX("shll    #%2, %0");
4466 #line 640 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4467                 ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F("OSZC");
4468
4469               }
4470             break;
4471         }
4472       break;
4473     case 0x6d:
4474         GETBYTE ();
4475         switch (op[1] & 0x00)
4476         {
4477           case 0x00:
4478             goto op_semantics_29;
4479             break;
4480         }
4481       break;
4482     case 0x6e:
4483         GETBYTE ();
4484         switch (op[1] & 0x00)
4485         {
4486           case 0x00:
4487               {
4488                 /** 0110 1110 dsta dstb         pushm   %1-%2 */
4489 #line 347 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4490                 int dsta AU = (op[1] >> 4) & 0x0f;
4491 #line 347 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4492                 int dstb AU = op[1] & 0x0f;
4493                 if (trace)
4494                   {
4495                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4496                            "/** 0110 1110 dsta dstb             pushm   %1-%2 */",
4497                            op[0], op[1]);
4498                     printf ("  dsta = 0x%x,", dsta);
4499                     printf ("  dstb = 0x%x\n", dstb);
4500                   }
4501                 SYNTAX("pushm   %1-%2");
4502 #line 348 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4503                 ID(pushm); SR(dsta); S2R(dstb); F("----");
4504
4505               }
4506             break;
4507         }
4508       break;
4509     case 0x6f:
4510         GETBYTE ();
4511         switch (op[1] & 0x00)
4512         {
4513           case 0x00:
4514               {
4515                 /** 0110 1111 dsta dstb         popm    %1-%2 */
4516 #line 344 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4517                 int dsta AU = (op[1] >> 4) & 0x0f;
4518 #line 344 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4519                 int dstb AU = op[1] & 0x0f;
4520                 if (trace)
4521                   {
4522                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4523                            "/** 0110 1111 dsta dstb             popm    %1-%2 */",
4524                            op[0], op[1]);
4525                     printf ("  dsta = 0x%x,", dsta);
4526                     printf ("  dstb = 0x%x\n", dstb);
4527                   }
4528                 SYNTAX("popm    %1-%2");
4529 #line 345 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4530                 ID(popm); SR(dsta); S2R(dstb); F("----");
4531
4532               }
4533             break;
4534         }
4535       break;
4536     case 0x70:
4537         GETBYTE ();
4538         switch (op[1] & 0x00)
4539         {
4540           case 0x00:
4541             op_semantics_30:
4542               {
4543                 /** 0111 00im rsrc rdst                 add     #%1, %2, %0 */
4544 #line 488 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4545                 int im AU = op[0] & 0x03;
4546 #line 488 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4547                 int rsrc AU = (op[1] >> 4) & 0x0f;
4548 #line 488 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4549                 int rdst AU = op[1] & 0x0f;
4550                 if (trace)
4551                   {
4552                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4553                            "/** 0111 00im rsrc rdst                     add     #%1, %2, %0 */",
4554                            op[0], op[1]);
4555                     printf ("  im = 0x%x,", im);
4556                     printf ("  rsrc = 0x%x,", rsrc);
4557                     printf ("  rdst = 0x%x\n", rdst);
4558                   }
4559                 SYNTAX("add     #%1, %2, %0");
4560 #line 489 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4561                 ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F("OSZC");
4562
4563               }
4564             break;
4565         }
4566       break;
4567     case 0x71:
4568         GETBYTE ();
4569         switch (op[1] & 0x00)
4570         {
4571           case 0x00:
4572             goto op_semantics_30;
4573             break;
4574         }
4575       break;
4576     case 0x72:
4577         GETBYTE ();
4578         switch (op[1] & 0x00)
4579         {
4580           case 0x00:
4581             goto op_semantics_30;
4582             break;
4583         }
4584       break;
4585     case 0x73:
4586         GETBYTE ();
4587         switch (op[1] & 0x00)
4588         {
4589           case 0x00:
4590             goto op_semantics_30;
4591             break;
4592         }
4593       break;
4594     case 0x74:
4595         GETBYTE ();
4596         switch (op[1] & 0xf0)
4597         {
4598           case 0x00:
4599             op_semantics_31:
4600               {
4601                 /** 0111 01im 0000 rsrc         cmp     #%2, %1%S1 */
4602 #line 500 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4603                 int im AU = op[0] & 0x03;
4604 #line 500 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4605                 int rsrc AU = op[1] & 0x0f;
4606                 if (trace)
4607                   {
4608                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4609                            "/** 0111 01im 0000 rsrc             cmp     #%2, %1%S1 */",
4610                            op[0], op[1]);
4611                     printf ("  im = 0x%x,", im);
4612                     printf ("  rsrc = 0x%x\n", rsrc);
4613                   }
4614                 SYNTAX("cmp     #%2, %1%S1");
4615 #line 501 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4616                 ID(sub); SR(rsrc); S2C(IMMex(im)); F("OSZC");
4617
4618               }
4619             break;
4620           case 0x10:
4621             op_semantics_32:
4622               {
4623                 /** 0111 01im 0001rdst                  mul     #%1, %0 */
4624 #line 576 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4625                 int im AU = op[0] & 0x03;
4626 #line 576 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4627                 int rdst AU = op[1] & 0x0f;
4628                 if (trace)
4629                   {
4630                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4631                            "/** 0111 01im 0001rdst                      mul     #%1, %0 */",
4632                            op[0], op[1]);
4633                     printf ("  im = 0x%x,", im);
4634                     printf ("  rdst = 0x%x\n", rdst);
4635                   }
4636                 SYNTAX("mul     #%1, %0");
4637 #line 577 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4638                 ID(mul); DR(rdst); SC(IMMex(im)); F("O---");
4639
4640               }
4641             break;
4642           case 0x20:
4643             op_semantics_33:
4644               {
4645                 /** 0111 01im 0010 rdst                 and     #%1, %0 */
4646 #line 392 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4647                 int im AU = op[0] & 0x03;
4648 #line 392 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4649                 int rdst AU = op[1] & 0x0f;
4650                 if (trace)
4651                   {
4652                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4653                            "/** 0111 01im 0010 rdst                     and     #%1, %0 */",
4654                            op[0], op[1]);
4655                     printf ("  im = 0x%x,", im);
4656                     printf ("  rdst = 0x%x\n", rdst);
4657                   }
4658                 SYNTAX("and     #%1, %0");
4659 #line 393 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4660                 ID(and); SC(IMMex(im)); DR(rdst); F("-SZ-");
4661
4662               }
4663             break;
4664           case 0x30:
4665             op_semantics_34:
4666               {
4667                 /** 0111 01im 0011 rdst                 or      #%1, %0 */
4668 #line 410 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4669                 int im AU = op[0] & 0x03;
4670 #line 410 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4671                 int rdst AU = op[1] & 0x0f;
4672                 if (trace)
4673                   {
4674                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4675                            "/** 0111 01im 0011 rdst                     or      #%1, %0 */",
4676                            op[0], op[1]);
4677                     printf ("  im = 0x%x,", im);
4678                     printf ("  rdst = 0x%x\n", rdst);
4679                   }
4680                 SYNTAX("or      #%1, %0");
4681 #line 411 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4682                 ID(or); SC(IMMex(im)); DR(rdst); F("-SZ-");
4683
4684               }
4685             break;
4686           default: UNSUPPORTED(); break;
4687         }
4688       break;
4689     case 0x75:
4690         GETBYTE ();
4691         switch (op[1] & 0xff)
4692         {
4693           case 0x00:
4694           case 0x01:
4695           case 0x02:
4696           case 0x03:
4697           case 0x04:
4698           case 0x05:
4699           case 0x06:
4700           case 0x07:
4701           case 0x08:
4702           case 0x09:
4703           case 0x0a:
4704           case 0x0b:
4705           case 0x0c:
4706           case 0x0d:
4707           case 0x0e:
4708           case 0x0f:
4709             goto op_semantics_31;
4710             break;
4711           case 0x10:
4712           case 0x11:
4713           case 0x12:
4714           case 0x13:
4715           case 0x14:
4716           case 0x15:
4717           case 0x16:
4718           case 0x17:
4719           case 0x18:
4720           case 0x19:
4721           case 0x1a:
4722           case 0x1b:
4723           case 0x1c:
4724           case 0x1d:
4725           case 0x1e:
4726           case 0x1f:
4727             goto op_semantics_32;
4728             break;
4729           case 0x20:
4730           case 0x21:
4731           case 0x22:
4732           case 0x23:
4733           case 0x24:
4734           case 0x25:
4735           case 0x26:
4736           case 0x27:
4737           case 0x28:
4738           case 0x29:
4739           case 0x2a:
4740           case 0x2b:
4741           case 0x2c:
4742           case 0x2d:
4743           case 0x2e:
4744           case 0x2f:
4745             goto op_semantics_33;
4746             break;
4747           case 0x30:
4748           case 0x31:
4749           case 0x32:
4750           case 0x33:
4751           case 0x34:
4752           case 0x35:
4753           case 0x36:
4754           case 0x37:
4755           case 0x38:
4756           case 0x39:
4757           case 0x3a:
4758           case 0x3b:
4759           case 0x3c:
4760           case 0x3d:
4761           case 0x3e:
4762           case 0x3f:
4763             goto op_semantics_34;
4764             break;
4765           case 0x40:
4766           case 0x41:
4767           case 0x42:
4768           case 0x43:
4769           case 0x44:
4770           case 0x45:
4771           case 0x46:
4772           case 0x47:
4773           case 0x48:
4774           case 0x49:
4775           case 0x4a:
4776           case 0x4b:
4777           case 0x4c:
4778           case 0x4d:
4779           case 0x4e:
4780           case 0x4f:
4781               {
4782                 /** 0111 0101 0100 rdst         mov%s   #%1, %0 */
4783 #line 285 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4784                 int rdst AU = op[1] & 0x0f;
4785                 if (trace)
4786                   {
4787                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4788                            "/** 0111 0101 0100 rdst             mov%s   #%1, %0 */",
4789                            op[0], op[1]);
4790                     printf ("  rdst = 0x%x\n", rdst);
4791                   }
4792                 SYNTAX("mov%s   #%1, %0");
4793 #line 286 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4794                 ID(mov); DR(rdst); SC(IMM (1)); F("----");
4795
4796               }
4797             break;
4798           case 0x50:
4799           case 0x51:
4800           case 0x52:
4801           case 0x53:
4802           case 0x54:
4803           case 0x55:
4804           case 0x56:
4805           case 0x57:
4806           case 0x58:
4807           case 0x59:
4808           case 0x5a:
4809           case 0x5b:
4810           case 0x5c:
4811           case 0x5d:
4812           case 0x5e:
4813           case 0x5f:
4814               {
4815                 /** 0111 0101 0101 rsrc                 cmp     #%2, %1 */
4816 #line 503 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4817                 int rsrc AU = op[1] & 0x0f;
4818                 if (trace)
4819                   {
4820                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4821                            "/** 0111 0101 0101 rsrc                     cmp     #%2, %1 */",
4822                            op[0], op[1]);
4823                     printf ("  rsrc = 0x%x\n", rsrc);
4824                   }
4825                 SYNTAX("cmp     #%2, %1");
4826 #line 504 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4827                 ID(sub); SR(rsrc); S2C(IMM(1)); F("OSZC");
4828
4829               }
4830             break;
4831           case 0x60:
4832               {
4833                 /** 0111 0101 0110 0000         int #%1 */
4834                 if (trace)
4835                   {
4836                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4837                            "/** 0111 0101 0110 0000             int #%1 */",
4838                            op[0], op[1]);
4839                   }
4840                 SYNTAX("int #%1");
4841 #line 963 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4842                 ID(int); SC(IMM(1));
4843
4844               }
4845             break;
4846           default: UNSUPPORTED(); break;
4847         }
4848       break;
4849     case 0x76:
4850         GETBYTE ();
4851         switch (op[1] & 0xf0)
4852         {
4853           case 0x00:
4854             goto op_semantics_31;
4855             break;
4856           case 0x10:
4857             goto op_semantics_32;
4858             break;
4859           case 0x20:
4860             goto op_semantics_33;
4861             break;
4862           case 0x30:
4863             goto op_semantics_34;
4864             break;
4865           default: UNSUPPORTED(); break;
4866         }
4867       break;
4868     case 0x77:
4869         GETBYTE ();
4870         switch (op[1] & 0xf0)
4871         {
4872           case 0x00:
4873             goto op_semantics_31;
4874             break;
4875           case 0x10:
4876             goto op_semantics_32;
4877             break;
4878           case 0x20:
4879             goto op_semantics_33;
4880             break;
4881           case 0x30:
4882             goto op_semantics_34;
4883             break;
4884           default: UNSUPPORTED(); break;
4885         }
4886       break;
4887     case 0x78:
4888         GETBYTE ();
4889         switch (op[1] & 0x00)
4890         {
4891           case 0x00:
4892             op_semantics_35:
4893               {
4894                 /** 0111 100b ittt rdst                 bset    #%1, %0 */
4895 #line 874 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4896                 int b AU = op[0] & 0x01;
4897 #line 874 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4898                 int ittt AU = (op[1] >> 4) & 0x0f;
4899 #line 874 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4900                 int rdst AU = op[1] & 0x0f;
4901                 if (trace)
4902                   {
4903                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4904                            "/** 0111 100b ittt rdst                     bset    #%1, %0 */",
4905                            op[0], op[1]);
4906                     printf ("  b = 0x%x,", b);
4907                     printf ("  ittt = 0x%x,", ittt);
4908                     printf ("  rdst = 0x%x\n", rdst);
4909                   }
4910                 SYNTAX("bset    #%1, %0");
4911 #line 875 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4912                 ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F("----");
4913
4914
4915               }
4916             break;
4917         }
4918       break;
4919     case 0x79:
4920         GETBYTE ();
4921         switch (op[1] & 0x00)
4922         {
4923           case 0x00:
4924             goto op_semantics_35;
4925             break;
4926         }
4927       break;
4928     case 0x7a:
4929         GETBYTE ();
4930         switch (op[1] & 0x00)
4931         {
4932           case 0x00:
4933             op_semantics_36:
4934               {
4935                 /** 0111 101b ittt rdst                 bclr    #%1, %0 */
4936 #line 884 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4937                 int b AU = op[0] & 0x01;
4938 #line 884 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4939                 int ittt AU = (op[1] >> 4) & 0x0f;
4940 #line 884 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4941                 int rdst AU = op[1] & 0x0f;
4942                 if (trace)
4943                   {
4944                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4945                            "/** 0111 101b ittt rdst                     bclr    #%1, %0 */",
4946                            op[0], op[1]);
4947                     printf ("  b = 0x%x,", b);
4948                     printf ("  ittt = 0x%x,", ittt);
4949                     printf ("  rdst = 0x%x\n", rdst);
4950                   }
4951                 SYNTAX("bclr    #%1, %0");
4952 #line 885 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4953                 ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F("----");
4954
4955
4956               }
4957             break;
4958         }
4959       break;
4960     case 0x7b:
4961         GETBYTE ();
4962         switch (op[1] & 0x00)
4963         {
4964           case 0x00:
4965             goto op_semantics_36;
4966             break;
4967         }
4968       break;
4969     case 0x7c:
4970         GETBYTE ();
4971         switch (op[1] & 0x00)
4972         {
4973           case 0x00:
4974             op_semantics_37:
4975               {
4976                 /** 0111 110b ittt rdst                 btst    #%2, %1 */
4977 #line 894 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4978                 int b AU = op[0] & 0x01;
4979 #line 894 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4980                 int ittt AU = (op[1] >> 4) & 0x0f;
4981 #line 894 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4982                 int rdst AU = op[1] & 0x0f;
4983                 if (trace)
4984                   {
4985                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4986                            "/** 0111 110b ittt rdst                     btst    #%2, %1 */",
4987                            op[0], op[1]);
4988                     printf ("  b = 0x%x,", b);
4989                     printf ("  ittt = 0x%x,", ittt);
4990                     printf ("  rdst = 0x%x\n", rdst);
4991                   }
4992                 SYNTAX("btst    #%2, %1");
4993 #line 895 "/work/sources/gcc/current/opcodes/rx-decode.opc"
4994                 ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F("--ZC");
4995
4996
4997               }
4998             break;
4999         }
5000       break;
5001     case 0x7d:
5002         GETBYTE ();
5003         switch (op[1] & 0x00)
5004         {
5005           case 0x00:
5006             goto op_semantics_37;
5007             break;
5008         }
5009       break;
5010     case 0x7e:
5011         GETBYTE ();
5012         switch (op[1] & 0xf0)
5013         {
5014           case 0x00:
5015               {
5016                 /** 0111 1110 0000 rdst                 not     %0 */
5017 #line 437 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5018                 int rdst AU = op[1] & 0x0f;
5019                 if (trace)
5020                   {
5021                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5022                            "/** 0111 1110 0000 rdst                     not     %0 */",
5023                            op[0], op[1]);
5024                     printf ("  rdst = 0x%x\n", rdst);
5025                   }
5026                 SYNTAX("not     %0");
5027 #line 438 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5028                 ID(xor); DR(rdst); SR(rdst); S2C(~0); F("-SZ-");
5029
5030               }
5031             break;
5032           case 0x10:
5033               {
5034                 /** 0111 1110 0001 rdst                 neg     %0 */
5035 #line 458 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5036                 int rdst AU = op[1] & 0x0f;
5037                 if (trace)
5038                   {
5039                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5040                            "/** 0111 1110 0001 rdst                     neg     %0 */",
5041                            op[0], op[1]);
5042                     printf ("  rdst = 0x%x\n", rdst);
5043                   }
5044                 SYNTAX("neg     %0");
5045 #line 459 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5046                 ID(sub); DR(rdst); SC(0); S2R(rdst); F("OSZC");
5047
5048               }
5049             break;
5050           case 0x20:
5051               {
5052                 /** 0111 1110 0010 rdst                 abs     %0 */
5053 #line 540 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5054                 int rdst AU = op[1] & 0x0f;
5055                 if (trace)
5056                   {
5057                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5058                            "/** 0111 1110 0010 rdst                     abs     %0 */",
5059                            op[0], op[1]);
5060                     printf ("  rdst = 0x%x\n", rdst);
5061                   }
5062                 SYNTAX("abs     %0");
5063 #line 541 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5064                 ID(abs); DR(rdst); SR(rdst); F("OSZ-");
5065
5066               }
5067             break;
5068           case 0x30:
5069               {
5070                 /** 0111 1110 0011 rdst         sat     %0 */
5071 #line 814 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5072                 int rdst AU = op[1] & 0x0f;
5073                 if (trace)
5074                   {
5075                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5076                            "/** 0111 1110 0011 rdst             sat     %0 */",
5077                            op[0], op[1]);
5078                     printf ("  rdst = 0x%x\n", rdst);
5079                   }
5080                 SYNTAX("sat     %0");
5081 #line 815 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5082                 ID(sat); DR (rdst);
5083
5084               }
5085             break;
5086           case 0x40:
5087               {
5088                 /** 0111 1110 0100 rdst                 rorc    %0 */
5089 #line 674 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5090                 int rdst AU = op[1] & 0x0f;
5091                 if (trace)
5092                   {
5093                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5094                            "/** 0111 1110 0100 rdst                     rorc    %0 */",
5095                            op[0], op[1]);
5096                     printf ("  rdst = 0x%x\n", rdst);
5097                   }
5098                 SYNTAX("rorc    %0");
5099 #line 675 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5100                 ID(rorc); DR(rdst); F("-SZC");
5101
5102               }
5103             break;
5104           case 0x50:
5105               {
5106                 /** 0111 1110 0101 rdst                 rolc    %0 */
5107 #line 671 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5108                 int rdst AU = op[1] & 0x0f;
5109                 if (trace)
5110                   {
5111                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5112                            "/** 0111 1110 0101 rdst                     rolc    %0 */",
5113                            op[0], op[1]);
5114                     printf ("  rdst = 0x%x\n", rdst);
5115                   }
5116                 SYNTAX("rolc    %0");
5117 #line 672 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5118                 ID(rolc); DR(rdst); F("-SZC");
5119
5120               }
5121             break;
5122           case 0x80:
5123           case 0x90:
5124           case 0xa0:
5125               {
5126                 /** 0111 1110 10sz rsrc         push%s  %1 */
5127 #line 353 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5128                 int sz AU = (op[1] >> 4) & 0x03;
5129 #line 353 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5130                 int rsrc AU = op[1] & 0x0f;
5131                 if (trace)
5132                   {
5133                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5134                            "/** 0111 1110 10sz rsrc             push%s  %1 */",
5135                            op[0], op[1]);
5136                     printf ("  sz = 0x%x,", sz);
5137                     printf ("  rsrc = 0x%x\n", rsrc);
5138                   }
5139                 SYNTAX("push%s  %1");
5140 #line 354 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5141                 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F("----");
5142
5143               }
5144             break;
5145           case 0xb0:
5146               {
5147                 /** 0111 1110 1011 rdst         pop     %0 */
5148 #line 350 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5149                 int rdst AU = op[1] & 0x0f;
5150                 if (trace)
5151                   {
5152                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5153                            "/** 0111 1110 1011 rdst             pop     %0 */",
5154                            op[0], op[1]);
5155                     printf ("  rdst = 0x%x\n", rdst);
5156                   }
5157                 SYNTAX("pop     %0");
5158 #line 351 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5159                 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F("----");
5160
5161               }
5162             break;
5163           case 0xc0:
5164           case 0xd0:
5165               {
5166                 /** 0111 1110 110 crsrc                 pushc   %1 */
5167 #line 926 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5168                 int crsrc AU = op[1] & 0x1f;
5169                 if (trace)
5170                   {
5171                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5172                            "/** 0111 1110 110 crsrc                     pushc   %1 */",
5173                            op[0], op[1]);
5174                     printf ("  crsrc = 0x%x\n", crsrc);
5175                   }
5176                 SYNTAX("pushc   %1");
5177 #line 927 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5178                 ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16);
5179
5180               }
5181             break;
5182           case 0xe0:
5183           case 0xf0:
5184               {
5185                 /** 0111 1110 111 crdst                 popc    %0 */
5186 #line 923 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5187                 int crdst AU = op[1] & 0x1f;
5188                 if (trace)
5189                   {
5190                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5191                            "/** 0111 1110 111 crdst                     popc    %0 */",
5192                            op[0], op[1]);
5193                     printf ("  crdst = 0x%x\n", crdst);
5194                   }
5195                 SYNTAX("popc    %0");
5196 #line 924 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5197                 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16);
5198
5199               }
5200             break;
5201           default: UNSUPPORTED(); break;
5202         }
5203       break;
5204     case 0x7f:
5205         GETBYTE ();
5206         switch (op[1] & 0xff)
5207         {
5208           case 0x00:
5209           case 0x01:
5210           case 0x02:
5211           case 0x03:
5212           case 0x04:
5213           case 0x05:
5214           case 0x06:
5215           case 0x07:
5216           case 0x08:
5217           case 0x09:
5218           case 0x0a:
5219           case 0x0b:
5220           case 0x0c:
5221           case 0x0d:
5222           case 0x0e:
5223           case 0x0f:
5224               {
5225                 /** 0111 1111 0000 rsrc         jmp     %0 */
5226 #line 724 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5227                 int rsrc AU = op[1] & 0x0f;
5228                 if (trace)
5229                   {
5230                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5231                            "/** 0111 1111 0000 rsrc             jmp     %0 */",
5232                            op[0], op[1]);
5233                     printf ("  rsrc = 0x%x\n", rsrc);
5234                   }
5235                 SYNTAX("jmp     %0");
5236 #line 725 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5237                 ID(branch); Scc(RXC_always); DR(rsrc);
5238
5239               }
5240             break;
5241           case 0x10:
5242           case 0x11:
5243           case 0x12:
5244           case 0x13:
5245           case 0x14:
5246           case 0x15:
5247           case 0x16:
5248           case 0x17:
5249           case 0x18:
5250           case 0x19:
5251           case 0x1a:
5252           case 0x1b:
5253           case 0x1c:
5254           case 0x1d:
5255           case 0x1e:
5256           case 0x1f:
5257               {
5258                 /** 0111 1111 0001 rsrc         jsr     %0 */
5259 #line 727 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5260                 int rsrc AU = op[1] & 0x0f;
5261                 if (trace)
5262                   {
5263                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5264                            "/** 0111 1111 0001 rsrc             jsr     %0 */",
5265                            op[0], op[1]);
5266                     printf ("  rsrc = 0x%x\n", rsrc);
5267                   }
5268                 SYNTAX("jsr     %0");
5269 #line 728 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5270                 ID(jsr); DR(rsrc);
5271
5272               }
5273             break;
5274           case 0x40:
5275           case 0x41:
5276           case 0x42:
5277           case 0x43:
5278           case 0x44:
5279           case 0x45:
5280           case 0x46:
5281           case 0x47:
5282           case 0x48:
5283           case 0x49:
5284           case 0x4a:
5285           case 0x4b:
5286           case 0x4c:
5287           case 0x4d:
5288           case 0x4e:
5289           case 0x4f:
5290               {
5291                 /** 0111 1111 0100 rsrc         bra.l   %0 */
5292 #line 720 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5293                 int rsrc AU = op[1] & 0x0f;
5294                 if (trace)
5295                   {
5296                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5297                            "/** 0111 1111 0100 rsrc             bra.l   %0 */",
5298                            op[0], op[1]);
5299                     printf ("  rsrc = 0x%x\n", rsrc);
5300                   }
5301                 SYNTAX("bra.l   %0");
5302 #line 721 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5303                 ID(branchrel); Scc(RXC_always); DR(rsrc);
5304
5305
5306               }
5307             break;
5308           case 0x50:
5309           case 0x51:
5310           case 0x52:
5311           case 0x53:
5312           case 0x54:
5313           case 0x55:
5314           case 0x56:
5315           case 0x57:
5316           case 0x58:
5317           case 0x59:
5318           case 0x5a:
5319           case 0x5b:
5320           case 0x5c:
5321           case 0x5d:
5322           case 0x5e:
5323           case 0x5f:
5324               {
5325                 /** 0111 1111 0101 rsrc         bsr.l   %0 */
5326 #line 736 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5327                 int rsrc AU = op[1] & 0x0f;
5328                 if (trace)
5329                   {
5330                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5331                            "/** 0111 1111 0101 rsrc             bsr.l   %0 */",
5332                            op[0], op[1]);
5333                     printf ("  rsrc = 0x%x\n", rsrc);
5334                   }
5335                 SYNTAX("bsr.l   %0");
5336 #line 737 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5337                 ID(jsrrel); DR(rsrc);
5338
5339               }
5340             break;
5341           case 0x80:
5342           case 0x81:
5343           case 0x82:
5344               {
5345                 /** 0111 1111 1000 00sz         suntil%s */
5346 #line 760 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5347                 int sz AU = op[1] & 0x03;
5348                 if (trace)
5349                   {
5350                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5351                            "/** 0111 1111 1000 00sz             suntil%s */",
5352                            op[0], op[1]);
5353                     printf ("  sz = 0x%x\n", sz);
5354                   }
5355                 SYNTAX("suntil%s");
5356 #line 761 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5357                 ID(suntil); BWL(sz); F("OSZC");
5358
5359               }
5360             break;
5361           case 0x83:
5362               {
5363                 /** 0111 1111 1000 0011         scmpu */
5364                 if (trace)
5365                   {
5366                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5367                            "/** 0111 1111 1000 0011             scmpu */",
5368                            op[0], op[1]);
5369                   }
5370                 SYNTAX("scmpu");
5371 #line 752 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5372                 ID(scmpu); F("--ZC");
5373
5374               }
5375             break;
5376           case 0x84:
5377           case 0x85:
5378           case 0x86:
5379               {
5380                 /** 0111 1111 1000 01sz         swhile%s */
5381 #line 763 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5382                 int sz AU = op[1] & 0x03;
5383                 if (trace)
5384                   {
5385                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5386                            "/** 0111 1111 1000 01sz             swhile%s */",
5387                            op[0], op[1]);
5388                     printf ("  sz = 0x%x\n", sz);
5389                   }
5390                 SYNTAX("swhile%s");
5391 #line 764 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5392                 ID(swhile); BWL(sz); F("OSZC");
5393
5394               }
5395             break;
5396           case 0x87:
5397               {
5398                 /** 0111 1111 1000 0111         smovu */
5399                 if (trace)
5400                   {
5401                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5402                            "/** 0111 1111 1000 0111             smovu */",
5403                            op[0], op[1]);
5404                   }
5405                 SYNTAX("smovu");
5406 #line 755 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5407                 ID(smovu);
5408
5409               }
5410             break;
5411           case 0x88:
5412           case 0x89:
5413           case 0x8a:
5414               {
5415                 /** 0111 1111 1000 10sz         sstr%s */
5416 #line 769 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5417                 int sz AU = op[1] & 0x03;
5418                 if (trace)
5419                   {
5420                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5421                            "/** 0111 1111 1000 10sz             sstr%s */",
5422                            op[0], op[1]);
5423                     printf ("  sz = 0x%x\n", sz);
5424                   }
5425                 SYNTAX("sstr%s");
5426 #line 770 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5427                 ID(sstr); BWL(sz);
5428
5429               /*----------------------------------------------------------------------*/
5430               /* RMPA                                                                   */
5431
5432               }
5433             break;
5434           case 0x8b:
5435               {
5436                 /** 0111 1111 1000 1011         smovb */
5437                 if (trace)
5438                   {
5439                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5440                            "/** 0111 1111 1000 1011             smovb */",
5441                            op[0], op[1]);
5442                   }
5443                 SYNTAX("smovb");
5444 #line 758 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5445                 ID(smovb);
5446
5447               }
5448             break;
5449           case 0x8c:
5450           case 0x8d:
5451           case 0x8e:
5452               {
5453                 /** 0111 1111 1000 11sz         rmpa%s */
5454 #line 775 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5455                 int sz AU = op[1] & 0x03;
5456                 if (trace)
5457                   {
5458                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5459                            "/** 0111 1111 1000 11sz             rmpa%s */",
5460                            op[0], op[1]);
5461                     printf ("  sz = 0x%x\n", sz);
5462                   }
5463                 SYNTAX("rmpa%s");
5464 #line 776 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5465                 ID(rmpa); BWL(sz); F("OS--");
5466
5467               /*----------------------------------------------------------------------*/
5468               /* HI/LO stuff                                                            */
5469
5470               }
5471             break;
5472           case 0x8f:
5473               {
5474                 /** 0111 1111 1000 1111         smovf */
5475                 if (trace)
5476                   {
5477                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5478                            "/** 0111 1111 1000 1111             smovf */",
5479                            op[0], op[1]);
5480                   }
5481                 SYNTAX("smovf");
5482 #line 767 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5483                 ID(smovf);
5484
5485               }
5486             break;
5487           case 0x93:
5488               {
5489                 /** 0111 1111 1001 0011         satr */
5490                 if (trace)
5491                   {
5492                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5493                            "/** 0111 1111 1001 0011             satr */",
5494                            op[0], op[1]);
5495                   }
5496                 SYNTAX("satr");
5497 #line 818 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5498                 ID(satr);
5499
5500               /*----------------------------------------------------------------------*/
5501               /* FLOAT                                                          */
5502
5503               }
5504             break;
5505           case 0x94:
5506               {
5507                 /** 0111 1111 1001 0100         rtfi */
5508                 if (trace)
5509                   {
5510                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5511                            "/** 0111 1111 1001 0100             rtfi */",
5512                            op[0], op[1]);
5513                   }
5514                 SYNTAX("rtfi");
5515 #line 951 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5516                 ID(rtfi);
5517
5518               }
5519             break;
5520           case 0x95:
5521               {
5522                 /** 0111 1111 1001 0101         rte */
5523                 if (trace)
5524                   {
5525                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5526                            "/** 0111 1111 1001 0101             rte */",
5527                            op[0], op[1]);
5528                   }
5529                 SYNTAX("rte");
5530 #line 954 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5531                 ID(rte);
5532
5533               }
5534             break;
5535           case 0x96:
5536               {
5537                 /** 0111 1111 1001 0110         wait */
5538                 if (trace)
5539                   {
5540                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5541                            "/** 0111 1111 1001 0110             wait */",
5542                            op[0], op[1]);
5543                   }
5544                 SYNTAX("wait");
5545 #line 966 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5546                 ID(wait);
5547
5548               /*----------------------------------------------------------------------*/
5549               /* SCcnd                                                          */
5550
5551               }
5552             break;
5553           case 0xa0:
5554           case 0xa1:
5555           case 0xa2:
5556           case 0xa3:
5557           case 0xa4:
5558           case 0xa5:
5559           case 0xa6:
5560           case 0xa7:
5561           case 0xa8:
5562           case 0xa9:
5563           case 0xaa:
5564           case 0xab:
5565           case 0xac:
5566           case 0xad:
5567           case 0xae:
5568           case 0xaf:
5569               {
5570                 /** 0111 1111 1010 rdst                 setpsw  %0 */
5571 #line 920 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5572                 int rdst AU = op[1] & 0x0f;
5573                 if (trace)
5574                   {
5575                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5576                            "/** 0111 1111 1010 rdst                     setpsw  %0 */",
5577                            op[0], op[1]);
5578                     printf ("  rdst = 0x%x\n", rdst);
5579                   }
5580                 SYNTAX("setpsw  %0");
5581 #line 921 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5582                 ID(setpsw); DF(rdst);
5583
5584               }
5585             break;
5586           case 0xb0:
5587           case 0xb1:
5588           case 0xb2:
5589           case 0xb3:
5590           case 0xb4:
5591           case 0xb5:
5592           case 0xb6:
5593           case 0xb7:
5594           case 0xb8:
5595           case 0xb9:
5596           case 0xba:
5597           case 0xbb:
5598           case 0xbc:
5599           case 0xbd:
5600           case 0xbe:
5601           case 0xbf:
5602               {
5603                 /** 0111 1111 1011 rdst                 clrpsw  %0 */
5604 #line 917 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5605                 int rdst AU = op[1] & 0x0f;
5606                 if (trace)
5607                   {
5608                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5609                            "/** 0111 1111 1011 rdst                     clrpsw  %0 */",
5610                            op[0], op[1]);
5611                     printf ("  rdst = 0x%x\n", rdst);
5612                   }
5613                 SYNTAX("clrpsw  %0");
5614 #line 918 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5615                 ID(clrpsw); DF(rdst);
5616
5617               }
5618             break;
5619           default: UNSUPPORTED(); break;
5620         }
5621       break;
5622     case 0x80:
5623         GETBYTE ();
5624         switch (op[1] & 0x00)
5625         {
5626           case 0x00:
5627             op_semantics_38:
5628               {
5629                 /** 10sz 0dsp a dst b src       mov%s   %1, %0 */
5630 #line 311 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5631                 int sz AU = (op[0] >> 4) & 0x03;
5632 #line 311 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5633                 int dsp AU = op[0] & 0x07;
5634 #line 311 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5635                 int a AU = (op[1] >> 7) & 0x01;
5636 #line 311 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5637                 int dst AU = (op[1] >> 4) & 0x07;
5638 #line 311 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5639                 int b AU = (op[1] >> 3) & 0x01;
5640 #line 311 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5641                 int src AU = op[1] & 0x07;
5642                 if (trace)
5643                   {
5644                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5645                            "/** 10sz 0dsp a dst b src   mov%s   %1, %0 */",
5646                            op[0], op[1]);
5647                     printf ("  sz = 0x%x,", sz);
5648                     printf ("  dsp = 0x%x,", dsp);
5649                     printf ("  a = 0x%x,", a);
5650                     printf ("  dst = 0x%x,", dst);
5651                     printf ("  b = 0x%x,", b);
5652                     printf ("  src = 0x%x\n", src);
5653                   }
5654                 SYNTAX("mov%s   %1, %0");
5655 #line 312 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5656                 ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F("----");
5657
5658               }
5659             break;
5660         }
5661       break;
5662     case 0x81:
5663         GETBYTE ();
5664         switch (op[1] & 0x00)
5665         {
5666           case 0x00:
5667             goto op_semantics_38;
5668             break;
5669         }
5670       break;
5671     case 0x82:
5672         GETBYTE ();
5673         switch (op[1] & 0x00)
5674         {
5675           case 0x00:
5676             goto op_semantics_38;
5677             break;
5678         }
5679       break;
5680     case 0x83:
5681         GETBYTE ();
5682         switch (op[1] & 0x00)
5683         {
5684           case 0x00:
5685             goto op_semantics_38;
5686             break;
5687         }
5688       break;
5689     case 0x84:
5690         GETBYTE ();
5691         switch (op[1] & 0x00)
5692         {
5693           case 0x00:
5694             goto op_semantics_38;
5695             break;
5696         }
5697       break;
5698     case 0x85:
5699         GETBYTE ();
5700         switch (op[1] & 0x00)
5701         {
5702           case 0x00:
5703             goto op_semantics_38;
5704             break;
5705         }
5706       break;
5707     case 0x86:
5708         GETBYTE ();
5709         switch (op[1] & 0x00)
5710         {
5711           case 0x00:
5712             goto op_semantics_38;
5713             break;
5714         }
5715       break;
5716     case 0x87:
5717         GETBYTE ();
5718         switch (op[1] & 0x00)
5719         {
5720           case 0x00:
5721             goto op_semantics_38;
5722             break;
5723         }
5724       break;
5725     case 0x88:
5726         GETBYTE ();
5727         switch (op[1] & 0x00)
5728         {
5729           case 0x00:
5730             op_semantics_39:
5731               {
5732                 /** 10sz 1dsp a src b dst       mov%s   %1, %0 */
5733 #line 308 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5734                 int sz AU = (op[0] >> 4) & 0x03;
5735 #line 308 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5736                 int dsp AU = op[0] & 0x07;
5737 #line 308 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5738                 int a AU = (op[1] >> 7) & 0x01;
5739 #line 308 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5740                 int src AU = (op[1] >> 4) & 0x07;
5741 #line 308 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5742                 int b AU = (op[1] >> 3) & 0x01;
5743 #line 308 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5744                 int dst AU = op[1] & 0x07;
5745                 if (trace)
5746                   {
5747                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5748                            "/** 10sz 1dsp a src b dst   mov%s   %1, %0 */",
5749                            op[0], op[1]);
5750                     printf ("  sz = 0x%x,", sz);
5751                     printf ("  dsp = 0x%x,", dsp);
5752                     printf ("  a = 0x%x,", a);
5753                     printf ("  src = 0x%x,", src);
5754                     printf ("  b = 0x%x,", b);
5755                     printf ("  dst = 0x%x\n", dst);
5756                   }
5757                 SYNTAX("mov%s   %1, %0");
5758 #line 309 "/work/sources/gcc/current/opcodes/rx-decode.opc"
5759                 ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F("----");
5760
5761               }
5762             break;
5763         }
5764       break;
5765     case 0x89:
5766         GETBYTE ();
5767         switch (op[1] & 0x00)
5768         {
5769           case 0x00:
5770             goto op_semantics_39;
5771             break;
5772         }
5773       break;
5774     case 0x8a:
5775         GETBYTE ();
5776         switch (op[1] & 0x00)
5777         {
5778           case 0x00:
5779             goto op_semantics_39;
5780             break;
5781         }
5782       break;
5783     case 0x8b:
5784         GETBYTE ();
5785         switch (op[1] & 0x00)
5786         {
5787           case 0x00:
5788             goto op_semantics_39;
5789             break;
5790         }
5791       break;
5792     case 0x8c:
5793         GETBYTE ();
5794         switch (op[1] & 0x00)
5795         {
5796           case 0x00:
5797             goto op_semantics_39;
5798             break;
5799         }
5800       break;
5801     case 0x8d:
5802         GETBYTE ();
5803         switch (op[1] & 0x00)
5804         {
5805           case 0x00:
5806             goto op_semantics_39;
5807             break;
5808         }
5809       break;
5810     case 0x8e:
5811         GETBYTE ();
5812         switch (op[1] & 0x00)
5813         {
5814           case 0x00:
5815             goto op_semantics_39;
5816             break;
5817         }
5818       break;
5819     case 0x8f:
5820         GETBYTE ();
5821         switch (op[1] & 0x00)
5822         {
5823           case 0x00:
5824             goto op_semantics_39;
5825             break;
5826         }
5827       break;
5828     case 0x90:
5829         GETBYTE ();
5830         switch (op[1] & 0x00)
5831         {
5832           case 0x00:
5833             goto op_semantics_38;
5834             break;
5835         }
5836       break;
5837     case 0x91:
5838         GETBYTE ();
5839         switch (op[1] & 0x00)
5840         {
5841           case 0x00:
5842             goto op_semantics_38;
5843             break;
5844         }
5845       break;
5846     case 0x92:
5847         GETBYTE ();
5848         switch (op[1] & 0x00)
5849         {
5850           case 0x00:
5851             goto op_semantics_38;
5852             break;
5853         }
5854       break;
5855     case 0x93:
5856         GETBYTE ();
5857         switch (op[1] & 0x00)
5858         {
5859           case 0x00:
5860             goto op_semantics_38;
5861             break;
5862         }
5863       break;
5864     case 0x94:
5865         GETBYTE ();
5866         switch (op[1] & 0x00)
5867         {
5868           case 0x00:
5869             goto op_semantics_38;
5870             break;
5871         }
5872       break;
5873     case 0x95:
5874         GETBYTE ();
5875         switch (op[1] & 0x00)
5876         {
5877           case 0x00:
5878             goto op_semantics_38;
5879             break;
5880         }
5881       break;
5882     case 0x96:
5883         GETBYTE ();
5884         switch (op[1] & 0x00)
5885         {
5886           case 0x00:
5887             goto op_semantics_38;
5888             break;
5889         }
5890       break;
5891     case 0x97:
5892         GETBYTE ();
5893         switch (op[1] & 0x00)
5894         {
5895           case 0x00:
5896             goto op_semantics_38;
5897             break;
5898         }
5899       break;
5900     case 0x98:
5901         GETBYTE ();
5902         switch (op[1] & 0x00)
5903         {
5904           case 0x00:
5905             goto op_semantics_39;
5906             break;
5907         }
5908       break;
5909     case 0x99:
5910         GETBYTE ();
5911         switch (op[1] & 0x00)
5912         {
5913           case 0x00:
5914             goto op_semantics_39;
5915             break;
5916         }
5917       break;
5918     case 0x9a:
5919         GETBYTE ();
5920         switch (op[1] & 0x00)
5921         {
5922           case 0x00:
5923             goto op_semantics_39;
5924             break;
5925         }
5926       break;
5927     case 0x9b:
5928         GETBYTE ();
5929         switch (op[1] & 0x00)
5930         {
5931           case 0x00:
5932             goto op_semantics_39;
5933             break;
5934         }
5935       break;
5936     case 0x9c:
5937         GETBYTE ();
5938         switch (op[1] & 0x00)
5939         {
5940           case 0x00:
5941             goto op_semantics_39;
5942             break;
5943         }
5944       break;
5945     case 0x9d:
5946         GETBYTE ();
5947         switch (op[1] & 0x00)
5948         {
5949           case 0x00:
5950             goto op_semantics_39;
5951             break;
5952         }
5953       break;
5954     case 0x9e:
5955         GETBYTE ();
5956         switch (op[1] & 0x00)
5957         {
5958           case 0x00:
5959             goto op_semantics_39;
5960             break;
5961         }
5962       break;
5963     case 0x9f:
5964         GETBYTE ();
5965         switch (op[1] & 0x00)
5966         {
5967           case 0x00:
5968             goto op_semantics_39;
5969             break;
5970         }
5971       break;
5972     case 0xa0:
5973         GETBYTE ();
5974         switch (op[1] & 0x00)
5975         {
5976           case 0x00:
5977             goto op_semantics_38;
5978             break;
5979         }
5980       break;
5981     case 0xa1:
5982         GETBYTE ();
5983         switch (op[1] & 0x00)
5984         {
5985           case 0x00:
5986             goto op_semantics_38;
5987             break;
5988         }
5989       break;
5990     case 0xa2:
5991         GETBYTE ();
5992         switch (op[1] & 0x00)
5993         {
5994           case 0x00:
5995             goto op_semantics_38;
5996             break;
5997         }
5998       break;
5999     case 0xa3:
6000         GETBYTE ();
6001         switch (op[1] & 0x00)
6002         {
6003           case 0x00:
6004             goto op_semantics_38;
6005             break;
6006         }
6007       break;
6008     case 0xa4:
6009         GETBYTE ();
6010         switch (op[1] & 0x00)
6011         {
6012           case 0x00:
6013             goto op_semantics_38;
6014             break;
6015         }
6016       break;
6017     case 0xa5:
6018         GETBYTE ();
6019         switch (op[1] & 0x00)
6020         {
6021           case 0x00:
6022             goto op_semantics_38;
6023             break;
6024         }
6025       break;
6026     case 0xa6:
6027         GETBYTE ();
6028         switch (op[1] & 0x00)
6029         {
6030           case 0x00:
6031             goto op_semantics_38;
6032             break;
6033         }
6034       break;
6035     case 0xa7:
6036         GETBYTE ();
6037         switch (op[1] & 0x00)
6038         {
6039           case 0x00:
6040             goto op_semantics_38;
6041             break;
6042         }
6043       break;
6044     case 0xa8:
6045         GETBYTE ();
6046         switch (op[1] & 0x00)
6047         {
6048           case 0x00:
6049             goto op_semantics_39;
6050             break;
6051         }
6052       break;
6053     case 0xa9:
6054         GETBYTE ();
6055         switch (op[1] & 0x00)
6056         {
6057           case 0x00:
6058             goto op_semantics_39;
6059             break;
6060         }
6061       break;
6062     case 0xaa:
6063         GETBYTE ();
6064         switch (op[1] & 0x00)
6065         {
6066           case 0x00:
6067             goto op_semantics_39;
6068             break;
6069         }
6070       break;
6071     case 0xab:
6072         GETBYTE ();
6073         switch (op[1] & 0x00)
6074         {
6075           case 0x00:
6076             goto op_semantics_39;
6077             break;
6078         }
6079       break;
6080     case 0xac:
6081         GETBYTE ();
6082         switch (op[1] & 0x00)
6083         {
6084           case 0x00:
6085             goto op_semantics_39;
6086             break;
6087         }
6088       break;
6089     case 0xad:
6090         GETBYTE ();
6091         switch (op[1] & 0x00)
6092         {
6093           case 0x00:
6094             goto op_semantics_39;
6095             break;
6096         }
6097       break;
6098     case 0xae:
6099         GETBYTE ();
6100         switch (op[1] & 0x00)
6101         {
6102           case 0x00:
6103             goto op_semantics_39;
6104             break;
6105         }
6106       break;
6107     case 0xaf:
6108         GETBYTE ();
6109         switch (op[1] & 0x00)
6110         {
6111           case 0x00:
6112             goto op_semantics_39;
6113             break;
6114         }
6115       break;
6116     case 0xb0:
6117         GETBYTE ();
6118         switch (op[1] & 0x00)
6119         {
6120           case 0x00:
6121             op_semantics_40:
6122               {
6123                 /** 1011 w dsp a src b dst      movu%s  %1, %0 */
6124 #line 331 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6125                 int w AU = (op[0] >> 3) & 0x01;
6126 #line 331 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6127                 int dsp AU = op[0] & 0x07;
6128 #line 331 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6129                 int a AU = (op[1] >> 7) & 0x01;
6130 #line 331 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6131                 int src AU = (op[1] >> 4) & 0x07;
6132 #line 331 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6133                 int b AU = (op[1] >> 3) & 0x01;
6134 #line 331 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6135                 int dst AU = op[1] & 0x07;
6136                 if (trace)
6137                   {
6138                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6139                            "/** 1011 w dsp a src b dst  movu%s  %1, %0 */",
6140                            op[0], op[1]);
6141                     printf ("  w = 0x%x,", w);
6142                     printf ("  dsp = 0x%x,", dsp);
6143                     printf ("  a = 0x%x,", a);
6144                     printf ("  src = 0x%x,", src);
6145                     printf ("  b = 0x%x,", b);
6146                     printf ("  dst = 0x%x\n", dst);
6147                   }
6148                 SYNTAX("movu%s  %1, %0");
6149 #line 332 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6150                 ID(mov); uBWL(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F("----");
6151
6152               }
6153             break;
6154         }
6155       break;
6156     case 0xb1:
6157         GETBYTE ();
6158         switch (op[1] & 0x00)
6159         {
6160           case 0x00:
6161             goto op_semantics_40;
6162             break;
6163         }
6164       break;
6165     case 0xb2:
6166         GETBYTE ();
6167         switch (op[1] & 0x00)
6168         {
6169           case 0x00:
6170             goto op_semantics_40;
6171             break;
6172         }
6173       break;
6174     case 0xb3:
6175         GETBYTE ();
6176         switch (op[1] & 0x00)
6177         {
6178           case 0x00:
6179             goto op_semantics_40;
6180             break;
6181         }
6182       break;
6183     case 0xb4:
6184         GETBYTE ();
6185         switch (op[1] & 0x00)
6186         {
6187           case 0x00:
6188             goto op_semantics_40;
6189             break;
6190         }
6191       break;
6192     case 0xb5:
6193         GETBYTE ();
6194         switch (op[1] & 0x00)
6195         {
6196           case 0x00:
6197             goto op_semantics_40;
6198             break;
6199         }
6200       break;
6201     case 0xb6:
6202         GETBYTE ();
6203         switch (op[1] & 0x00)
6204         {
6205           case 0x00:
6206             goto op_semantics_40;
6207             break;
6208         }
6209       break;
6210     case 0xb7:
6211         GETBYTE ();
6212         switch (op[1] & 0x00)
6213         {
6214           case 0x00:
6215             goto op_semantics_40;
6216             break;
6217         }
6218       break;
6219     case 0xb8:
6220         GETBYTE ();
6221         switch (op[1] & 0x00)
6222         {
6223           case 0x00:
6224             goto op_semantics_40;
6225             break;
6226         }
6227       break;
6228     case 0xb9:
6229         GETBYTE ();
6230         switch (op[1] & 0x00)
6231         {
6232           case 0x00:
6233             goto op_semantics_40;
6234             break;
6235         }
6236       break;
6237     case 0xba:
6238         GETBYTE ();
6239         switch (op[1] & 0x00)
6240         {
6241           case 0x00:
6242             goto op_semantics_40;
6243             break;
6244         }
6245       break;
6246     case 0xbb:
6247         GETBYTE ();
6248         switch (op[1] & 0x00)
6249         {
6250           case 0x00:
6251             goto op_semantics_40;
6252             break;
6253         }
6254       break;
6255     case 0xbc:
6256         GETBYTE ();
6257         switch (op[1] & 0x00)
6258         {
6259           case 0x00:
6260             goto op_semantics_40;
6261             break;
6262         }
6263       break;
6264     case 0xbd:
6265         GETBYTE ();
6266         switch (op[1] & 0x00)
6267         {
6268           case 0x00:
6269             goto op_semantics_40;
6270             break;
6271         }
6272       break;
6273     case 0xbe:
6274         GETBYTE ();
6275         switch (op[1] & 0x00)
6276         {
6277           case 0x00:
6278             goto op_semantics_40;
6279             break;
6280         }
6281       break;
6282     case 0xbf:
6283         GETBYTE ();
6284         switch (op[1] & 0x00)
6285         {
6286           case 0x00:
6287             goto op_semantics_40;
6288             break;
6289         }
6290       break;
6291     case 0xc0:
6292         GETBYTE ();
6293         switch (op[1] & 0x00)
6294         {
6295           case 0x00:
6296             op_semantics_41:
6297               {
6298                 /** 11sz sd ss rsrc rdst        mov%s   %1, %0 */
6299 #line 297 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6300                 int sz AU = (op[0] >> 4) & 0x03;
6301 #line 297 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6302                 int sd AU = (op[0] >> 2) & 0x03;
6303 #line 297 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6304                 int ss AU = op[0] & 0x03;
6305 #line 297 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6306                 int rsrc AU = (op[1] >> 4) & 0x0f;
6307 #line 297 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6308                 int rdst AU = op[1] & 0x0f;
6309                 if (trace)
6310                   {
6311                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6312                            "/** 11sz sd ss rsrc rdst    mov%s   %1, %0 */",
6313                            op[0], op[1]);
6314                     printf ("  sz = 0x%x,", sz);
6315                     printf ("  sd = 0x%x,", sd);
6316                     printf ("  ss = 0x%x,", ss);
6317                     printf ("  rsrc = 0x%x,", rsrc);
6318                     printf ("  rdst = 0x%x\n", rdst);
6319                   }
6320                 SYNTAX("mov%s   %1, %0");
6321 #line 298 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6322                 ID(mov); sBWL(sz); F("----");
6323                 if ((ss == 3) && (sd != 3))
6324                   {
6325                     SD(ss, rdst, sz); DD(sd, rsrc, sz);
6326                   }
6327                 else
6328                   {
6329                     SD(ss, rsrc, sz); DD(sd, rdst, sz);
6330                   }
6331
6332               }
6333             break;
6334         }
6335       break;
6336     case 0xc1:
6337         GETBYTE ();
6338         switch (op[1] & 0x00)
6339         {
6340           case 0x00:
6341             goto op_semantics_41;
6342             break;
6343         }
6344       break;
6345     case 0xc2:
6346         GETBYTE ();
6347         switch (op[1] & 0x00)
6348         {
6349           case 0x00:
6350             goto op_semantics_41;
6351             break;
6352         }
6353       break;
6354     case 0xc3:
6355         GETBYTE ();
6356         switch (op[1] & 0x00)
6357         {
6358           case 0x00:
6359             goto op_semantics_41;
6360             break;
6361         }
6362       break;
6363     case 0xc4:
6364         GETBYTE ();
6365         switch (op[1] & 0x00)
6366         {
6367           case 0x00:
6368             goto op_semantics_41;
6369             break;
6370         }
6371       break;
6372     case 0xc5:
6373         GETBYTE ();
6374         switch (op[1] & 0x00)
6375         {
6376           case 0x00:
6377             goto op_semantics_41;
6378             break;
6379         }
6380       break;
6381     case 0xc6:
6382         GETBYTE ();
6383         switch (op[1] & 0x00)
6384         {
6385           case 0x00:
6386             goto op_semantics_41;
6387             break;
6388         }
6389       break;
6390     case 0xc7:
6391         GETBYTE ();
6392         switch (op[1] & 0x00)
6393         {
6394           case 0x00:
6395             goto op_semantics_41;
6396             break;
6397         }
6398       break;
6399     case 0xc8:
6400         GETBYTE ();
6401         switch (op[1] & 0x00)
6402         {
6403           case 0x00:
6404             goto op_semantics_41;
6405             break;
6406         }
6407       break;
6408     case 0xc9:
6409         GETBYTE ();
6410         switch (op[1] & 0x00)
6411         {
6412           case 0x00:
6413             goto op_semantics_41;
6414             break;
6415         }
6416       break;
6417     case 0xca:
6418         GETBYTE ();
6419         switch (op[1] & 0x00)
6420         {
6421           case 0x00:
6422             goto op_semantics_41;
6423             break;
6424         }
6425       break;
6426     case 0xcb:
6427         GETBYTE ();
6428         switch (op[1] & 0x00)
6429         {
6430           case 0x00:
6431             goto op_semantics_41;
6432             break;
6433         }
6434       break;
6435     case 0xcc:
6436         GETBYTE ();
6437         switch (op[1] & 0x00)
6438         {
6439           case 0x00:
6440             goto op_semantics_41;
6441             break;
6442         }
6443       break;
6444     case 0xcd:
6445         GETBYTE ();
6446         switch (op[1] & 0x00)
6447         {
6448           case 0x00:
6449             goto op_semantics_41;
6450             break;
6451         }
6452       break;
6453     case 0xce:
6454         GETBYTE ();
6455         switch (op[1] & 0x00)
6456         {
6457           case 0x00:
6458             goto op_semantics_41;
6459             break;
6460         }
6461       break;
6462     case 0xcf:
6463         GETBYTE ();
6464         switch (op[1] & 0x00)
6465         {
6466           case 0x00:
6467             goto op_semantics_41;
6468             break;
6469         }
6470       break;
6471     case 0xd0:
6472         GETBYTE ();
6473         switch (op[1] & 0x00)
6474         {
6475           case 0x00:
6476             goto op_semantics_41;
6477             break;
6478         }
6479       break;
6480     case 0xd1:
6481         GETBYTE ();
6482         switch (op[1] & 0x00)
6483         {
6484           case 0x00:
6485             goto op_semantics_41;
6486             break;
6487         }
6488       break;
6489     case 0xd2:
6490         GETBYTE ();
6491         switch (op[1] & 0x00)
6492         {
6493           case 0x00:
6494             goto op_semantics_41;
6495             break;
6496         }
6497       break;
6498     case 0xd3:
6499         GETBYTE ();
6500         switch (op[1] & 0x00)
6501         {
6502           case 0x00:
6503             goto op_semantics_41;
6504             break;
6505         }
6506       break;
6507     case 0xd4:
6508         GETBYTE ();
6509         switch (op[1] & 0x00)
6510         {
6511           case 0x00:
6512             goto op_semantics_41;
6513             break;
6514         }
6515       break;
6516     case 0xd5:
6517         GETBYTE ();
6518         switch (op[1] & 0x00)
6519         {
6520           case 0x00:
6521             goto op_semantics_41;
6522             break;
6523         }
6524       break;
6525     case 0xd6:
6526         GETBYTE ();
6527         switch (op[1] & 0x00)
6528         {
6529           case 0x00:
6530             goto op_semantics_41;
6531             break;
6532         }
6533       break;
6534     case 0xd7:
6535         GETBYTE ();
6536         switch (op[1] & 0x00)
6537         {
6538           case 0x00:
6539             goto op_semantics_41;
6540             break;
6541         }
6542       break;
6543     case 0xd8:
6544         GETBYTE ();
6545         switch (op[1] & 0x00)
6546         {
6547           case 0x00:
6548             goto op_semantics_41;
6549             break;
6550         }
6551       break;
6552     case 0xd9:
6553         GETBYTE ();
6554         switch (op[1] & 0x00)
6555         {
6556           case 0x00:
6557             goto op_semantics_41;
6558             break;
6559         }
6560       break;
6561     case 0xda:
6562         GETBYTE ();
6563         switch (op[1] & 0x00)
6564         {
6565           case 0x00:
6566             goto op_semantics_41;
6567             break;
6568         }
6569       break;
6570     case 0xdb:
6571         GETBYTE ();
6572         switch (op[1] & 0x00)
6573         {
6574           case 0x00:
6575             goto op_semantics_41;
6576             break;
6577         }
6578       break;
6579     case 0xdc:
6580         GETBYTE ();
6581         switch (op[1] & 0x00)
6582         {
6583           case 0x00:
6584             goto op_semantics_41;
6585             break;
6586         }
6587       break;
6588     case 0xdd:
6589         GETBYTE ();
6590         switch (op[1] & 0x00)
6591         {
6592           case 0x00:
6593             goto op_semantics_41;
6594             break;
6595         }
6596       break;
6597     case 0xde:
6598         GETBYTE ();
6599         switch (op[1] & 0x00)
6600         {
6601           case 0x00:
6602             goto op_semantics_41;
6603             break;
6604         }
6605       break;
6606     case 0xdf:
6607         GETBYTE ();
6608         switch (op[1] & 0x00)
6609         {
6610           case 0x00:
6611             goto op_semantics_41;
6612             break;
6613         }
6614       break;
6615     case 0xe0:
6616         GETBYTE ();
6617         switch (op[1] & 0x00)
6618         {
6619           case 0x00:
6620             goto op_semantics_41;
6621             break;
6622         }
6623       break;
6624     case 0xe1:
6625         GETBYTE ();
6626         switch (op[1] & 0x00)
6627         {
6628           case 0x00:
6629             goto op_semantics_41;
6630             break;
6631         }
6632       break;
6633     case 0xe2:
6634         GETBYTE ();
6635         switch (op[1] & 0x00)
6636         {
6637           case 0x00:
6638             goto op_semantics_41;
6639             break;
6640         }
6641       break;
6642     case 0xe3:
6643         GETBYTE ();
6644         switch (op[1] & 0x00)
6645         {
6646           case 0x00:
6647             goto op_semantics_41;
6648             break;
6649         }
6650       break;
6651     case 0xe4:
6652         GETBYTE ();
6653         switch (op[1] & 0x00)
6654         {
6655           case 0x00:
6656             goto op_semantics_41;
6657             break;
6658         }
6659       break;
6660     case 0xe5:
6661         GETBYTE ();
6662         switch (op[1] & 0x00)
6663         {
6664           case 0x00:
6665             goto op_semantics_41;
6666             break;
6667         }
6668       break;
6669     case 0xe6:
6670         GETBYTE ();
6671         switch (op[1] & 0x00)
6672         {
6673           case 0x00:
6674             goto op_semantics_41;
6675             break;
6676         }
6677       break;
6678     case 0xe7:
6679         GETBYTE ();
6680         switch (op[1] & 0x00)
6681         {
6682           case 0x00:
6683             goto op_semantics_41;
6684             break;
6685         }
6686       break;
6687     case 0xe8:
6688         GETBYTE ();
6689         switch (op[1] & 0x00)
6690         {
6691           case 0x00:
6692             goto op_semantics_41;
6693             break;
6694         }
6695       break;
6696     case 0xe9:
6697         GETBYTE ();
6698         switch (op[1] & 0x00)
6699         {
6700           case 0x00:
6701             goto op_semantics_41;
6702             break;
6703         }
6704       break;
6705     case 0xea:
6706         GETBYTE ();
6707         switch (op[1] & 0x00)
6708         {
6709           case 0x00:
6710             goto op_semantics_41;
6711             break;
6712         }
6713       break;
6714     case 0xeb:
6715         GETBYTE ();
6716         switch (op[1] & 0x00)
6717         {
6718           case 0x00:
6719             goto op_semantics_41;
6720             break;
6721         }
6722       break;
6723     case 0xec:
6724         GETBYTE ();
6725         switch (op[1] & 0x00)
6726         {
6727           case 0x00:
6728             goto op_semantics_41;
6729             break;
6730         }
6731       break;
6732     case 0xed:
6733         GETBYTE ();
6734         switch (op[1] & 0x00)
6735         {
6736           case 0x00:
6737             goto op_semantics_41;
6738             break;
6739         }
6740       break;
6741     case 0xee:
6742         GETBYTE ();
6743         switch (op[1] & 0x00)
6744         {
6745           case 0x00:
6746             goto op_semantics_41;
6747             break;
6748         }
6749       break;
6750     case 0xef:
6751         GETBYTE ();
6752         switch (op[1] & 0x00)
6753         {
6754           case 0x00:
6755             goto op_semantics_41;
6756             break;
6757         }
6758       break;
6759     case 0xf0:
6760         GETBYTE ();
6761         switch (op[1] & 0x08)
6762         {
6763           case 0x00:
6764             op_semantics_42:
6765               {
6766                 /** 1111 00sd rdst 0bit                 bset    #%1, %0%S0 */
6767 #line 868 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6768                 int sd AU = op[0] & 0x03;
6769 #line 868 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6770                 int rdst AU = (op[1] >> 4) & 0x0f;
6771 #line 868 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6772                 int bit AU = op[1] & 0x07;
6773                 if (trace)
6774                   {
6775                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6776                            "/** 1111 00sd rdst 0bit                     bset    #%1, %0%S0 */",
6777                            op[0], op[1]);
6778                     printf ("  sd = 0x%x,", sd);
6779                     printf ("  rdst = 0x%x,", rdst);
6780                     printf ("  bit = 0x%x\n", bit);
6781                   }
6782                 SYNTAX("bset    #%1, %0%S0");
6783 #line 869 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6784                 ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F("----");
6785
6786               }
6787             break;
6788           case 0x08:
6789             op_semantics_43:
6790               {
6791                 /** 1111 00sd rdst 1bit                 bclr    #%1, %0%S0 */
6792 #line 878 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6793                 int sd AU = op[0] & 0x03;
6794 #line 878 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6795                 int rdst AU = (op[1] >> 4) & 0x0f;
6796 #line 878 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6797                 int bit AU = op[1] & 0x07;
6798                 if (trace)
6799                   {
6800                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6801                            "/** 1111 00sd rdst 1bit                     bclr    #%1, %0%S0 */",
6802                            op[0], op[1]);
6803                     printf ("  sd = 0x%x,", sd);
6804                     printf ("  rdst = 0x%x,", rdst);
6805                     printf ("  bit = 0x%x\n", bit);
6806                   }
6807                 SYNTAX("bclr    #%1, %0%S0");
6808 #line 879 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6809                 ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F("----");
6810
6811               }
6812             break;
6813         }
6814       break;
6815     case 0xf1:
6816         GETBYTE ();
6817         switch (op[1] & 0x08)
6818         {
6819           case 0x00:
6820             goto op_semantics_42;
6821             break;
6822           case 0x08:
6823             goto op_semantics_43;
6824             break;
6825         }
6826       break;
6827     case 0xf2:
6828         GETBYTE ();
6829         switch (op[1] & 0x08)
6830         {
6831           case 0x00:
6832             goto op_semantics_42;
6833             break;
6834           case 0x08:
6835             goto op_semantics_43;
6836             break;
6837         }
6838       break;
6839     case 0xf3:
6840         GETBYTE ();
6841         switch (op[1] & 0x08)
6842         {
6843           case 0x00:
6844             goto op_semantics_42;
6845             break;
6846           case 0x08:
6847             goto op_semantics_43;
6848             break;
6849         }
6850       break;
6851     case 0xf4:
6852         GETBYTE ();
6853         switch (op[1] & 0x0c)
6854         {
6855           case 0x00:
6856           case 0x04:
6857             op_semantics_44:
6858               {
6859                 /** 1111 01sd rdst 0bit                 btst    #%2, %1%S1 */
6860 #line 888 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6861                 int sd AU = op[0] & 0x03;
6862 #line 888 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6863                 int rdst AU = (op[1] >> 4) & 0x0f;
6864 #line 888 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6865                 int bit AU = op[1] & 0x07;
6866                 if (trace)
6867                   {
6868                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6869                            "/** 1111 01sd rdst 0bit                     btst    #%2, %1%S1 */",
6870                            op[0], op[1]);
6871                     printf ("  sd = 0x%x,", sd);
6872                     printf ("  rdst = 0x%x,", rdst);
6873                     printf ("  bit = 0x%x\n", bit);
6874                   }
6875                 SYNTAX("btst    #%2, %1%S1");
6876 #line 889 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6877                 ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F("--ZC");
6878
6879               }
6880             break;
6881           case 0x08:
6882             op_semantics_45:
6883               {
6884                 /** 1111 01ss rsrc 10sz         push%s  %1 */
6885 #line 356 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6886                 int ss AU = op[0] & 0x03;
6887 #line 356 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6888                 int rsrc AU = (op[1] >> 4) & 0x0f;
6889 #line 356 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6890                 int sz AU = op[1] & 0x03;
6891                 if (trace)
6892                   {
6893                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6894                            "/** 1111 01ss rsrc 10sz             push%s  %1 */",
6895                            op[0], op[1]);
6896                     printf ("  ss = 0x%x,", ss);
6897                     printf ("  rsrc = 0x%x,", rsrc);
6898                     printf ("  sz = 0x%x\n", sz);
6899                   }
6900                 SYNTAX("push%s  %1");
6901 #line 357 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6902                 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F("----");
6903
6904               /*----------------------------------------------------------------------*/
6905               /* XCHG                                                                   */
6906
6907               }
6908             break;
6909           default: UNSUPPORTED(); break;
6910         }
6911       break;
6912     case 0xf5:
6913         GETBYTE ();
6914         switch (op[1] & 0x0c)
6915         {
6916           case 0x00:
6917           case 0x04:
6918             goto op_semantics_44;
6919             break;
6920           case 0x08:
6921             goto op_semantics_45;
6922             break;
6923           default: UNSUPPORTED(); break;
6924         }
6925       break;
6926     case 0xf6:
6927         GETBYTE ();
6928         switch (op[1] & 0x0c)
6929         {
6930           case 0x00:
6931           case 0x04:
6932             goto op_semantics_44;
6933             break;
6934           case 0x08:
6935             goto op_semantics_45;
6936             break;
6937           default: UNSUPPORTED(); break;
6938         }
6939       break;
6940     case 0xf7:
6941         GETBYTE ();
6942         switch (op[1] & 0x0c)
6943         {
6944           case 0x00:
6945           case 0x04:
6946             goto op_semantics_44;
6947             break;
6948           case 0x08:
6949             goto op_semantics_45;
6950             break;
6951           default: UNSUPPORTED(); break;
6952         }
6953       break;
6954     case 0xf8:
6955         GETBYTE ();
6956         switch (op[1] & 0x00)
6957         {
6958           case 0x00:
6959             op_semantics_46:
6960               {
6961                 /** 1111 10sd rdst im sz        mov%s   #%1, %0 */
6962 #line 288 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6963                 int sd AU = op[0] & 0x03;
6964 #line 288 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6965                 int rdst AU = (op[1] >> 4) & 0x0f;
6966 #line 288 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6967                 int im AU = (op[1] >> 2) & 0x03;
6968 #line 288 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6969                 int sz AU = op[1] & 0x03;
6970                 if (trace)
6971                   {
6972                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6973                            "/** 1111 10sd rdst im sz    mov%s   #%1, %0 */",
6974                            op[0], op[1]);
6975                     printf ("  sd = 0x%x,", sd);
6976                     printf ("  rdst = 0x%x,", rdst);
6977                     printf ("  im = 0x%x,", im);
6978                     printf ("  sz = 0x%x\n", sz);
6979                   }
6980                 SYNTAX("mov%s   #%1, %0");
6981 #line 289 "/work/sources/gcc/current/opcodes/rx-decode.opc"
6982                 ID(mov); sBWL (sz); DD(sd, rdst, sz); SC(IMMex(im)); F("----");
6983
6984               }
6985             break;
6986         }
6987       break;
6988     case 0xf9:
6989         GETBYTE ();
6990         switch (op[1] & 0x00)
6991         {
6992           case 0x00:
6993             goto op_semantics_46;
6994             break;
6995         }
6996       break;
6997     case 0xfa:
6998         GETBYTE ();
6999         switch (op[1] & 0x00)
7000         {
7001           case 0x00:
7002             goto op_semantics_46;
7003             break;
7004         }
7005       break;
7006     case 0xfb:
7007         GETBYTE ();
7008         switch (op[1] & 0x00)
7009         {
7010           case 0x00:
7011             goto op_semantics_46;
7012             break;
7013         }
7014       break;
7015     case 0xfc:
7016         GETBYTE ();
7017         switch (op[1] & 0xff)
7018         {
7019           case 0x03:
7020               GETBYTE ();
7021               switch (op[2] & 0x00)
7022               {
7023                 case 0x00:
7024                     {
7025                       /** 1111 1100 0000 0011 rsrc rdst sbb     %1, %0 */
7026 #line 530 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7027                       int rsrc AU = (op[2] >> 4) & 0x0f;
7028 #line 530 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7029                       int rdst AU = op[2] & 0x0f;
7030                       if (trace)
7031                         {
7032                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7033                                  "/** 1111 1100 0000 0011 rsrc rdst     sbb     %1, %0 */",
7034                                  op[0], op[1], op[2]);
7035                           printf ("  rsrc = 0x%x,", rsrc);
7036                           printf ("  rdst = 0x%x\n", rdst);
7037                         }
7038                       SYNTAX("sbb       %1, %0");
7039 #line 531 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7040                       ID(sbb); SR (rsrc); DR(rdst); F("OSZC");
7041
7042                       /* FIXME: only supports .L */
7043                     }
7044                   break;
7045               }
7046             break;
7047           case 0x07:
7048               GETBYTE ();
7049               switch (op[2] & 0x00)
7050               {
7051                 case 0x00:
7052                     {
7053                       /** 1111 1100 0000 0111 rsrc rdst neg     %2, %0 */
7054 #line 461 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7055                       int rsrc AU = (op[2] >> 4) & 0x0f;
7056 #line 461 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7057                       int rdst AU = op[2] & 0x0f;
7058                       if (trace)
7059                         {
7060                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7061                                  "/** 1111 1100 0000 0111 rsrc rdst     neg     %2, %0 */",
7062                                  op[0], op[1], op[2]);
7063                           printf ("  rsrc = 0x%x,", rsrc);
7064                           printf ("  rdst = 0x%x\n", rdst);
7065                         }
7066                       SYNTAX("neg       %2, %0");
7067 #line 462 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7068                       ID(sub); DR(rdst); SC(0); S2R(rsrc); F("OSZC");
7069
7070                     /*----------------------------------------------------------------------*/
7071                     /* ADC                                                                      */
7072
7073                     }
7074                   break;
7075               }
7076             break;
7077           case 0x0b:
7078               GETBYTE ();
7079               switch (op[2] & 0x00)
7080               {
7081                 case 0x00:
7082                     {
7083                       /** 1111 1100 0000 1011 rsrc rdst adc     %1, %0 */
7084 #line 470 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7085                       int rsrc AU = (op[2] >> 4) & 0x0f;
7086 #line 470 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7087                       int rdst AU = op[2] & 0x0f;
7088                       if (trace)
7089                         {
7090                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7091                                  "/** 1111 1100 0000 1011 rsrc rdst     adc     %1, %0 */",
7092                                  op[0], op[1], op[2]);
7093                           printf ("  rsrc = 0x%x,", rsrc);
7094                           printf ("  rdst = 0x%x\n", rdst);
7095                         }
7096                       SYNTAX("adc       %1, %0");
7097 #line 471 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7098                       ID(adc); SR(rsrc); DR(rdst); F("OSZC");
7099
7100                     }
7101                   break;
7102               }
7103             break;
7104           case 0x0f:
7105               GETBYTE ();
7106               switch (op[2] & 0x00)
7107               {
7108                 case 0x00:
7109                     {
7110                       /** 1111 1100 0000 1111 rsrc rdst abs     %1, %0 */
7111 #line 543 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7112                       int rsrc AU = (op[2] >> 4) & 0x0f;
7113 #line 543 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7114                       int rdst AU = op[2] & 0x0f;
7115                       if (trace)
7116                         {
7117                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7118                                  "/** 1111 1100 0000 1111 rsrc rdst     abs     %1, %0 */",
7119                                  op[0], op[1], op[2]);
7120                           printf ("  rsrc = 0x%x,", rsrc);
7121                           printf ("  rdst = 0x%x\n", rdst);
7122                         }
7123                       SYNTAX("abs       %1, %0");
7124 #line 544 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7125                       ID(abs); DR(rdst); SR(rsrc); F("OSZ-");
7126
7127                     /*----------------------------------------------------------------------*/
7128                     /* MAX                                                                      */
7129
7130                     }
7131                   break;
7132               }
7133             break;
7134           case 0x10:
7135               GETBYTE ();
7136               switch (op[2] & 0x00)
7137               {
7138                 case 0x00:
7139                   op_semantics_47:
7140                     {
7141                       /** 1111 1100 0001 00ss rsrc rdst max     %1%S1, %0 */
7142 #line 552 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7143                       int ss AU = op[1] & 0x03;
7144 #line 552 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7145                       int rsrc AU = (op[2] >> 4) & 0x0f;
7146 #line 552 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7147                       int rdst AU = op[2] & 0x0f;
7148                       if (trace)
7149                         {
7150                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7151                                  "/** 1111 1100 0001 00ss rsrc rdst     max     %1%S1, %0 */",
7152                                  op[0], op[1], op[2]);
7153                           printf ("  ss = 0x%x,", ss);
7154                           printf ("  rsrc = 0x%x,", rsrc);
7155                           printf ("  rdst = 0x%x\n", rdst);
7156                         }
7157                       SYNTAX("max       %1%S1, %0");
7158 #line 553 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7159                       ID(max); SP(ss, rsrc); DR(rdst);
7160
7161                     }
7162                   break;
7163               }
7164             break;
7165           case 0x11:
7166               GETBYTE ();
7167               switch (op[2] & 0x00)
7168               {
7169                 case 0x00:
7170                   goto op_semantics_47;
7171                   break;
7172               }
7173             break;
7174           case 0x12:
7175               GETBYTE ();
7176               switch (op[2] & 0x00)
7177               {
7178                 case 0x00:
7179                   goto op_semantics_47;
7180                   break;
7181               }
7182             break;
7183           case 0x13:
7184               GETBYTE ();
7185               switch (op[2] & 0x00)
7186               {
7187                 case 0x00:
7188                   goto op_semantics_47;
7189                   break;
7190               }
7191             break;
7192           case 0x14:
7193               GETBYTE ();
7194               switch (op[2] & 0x00)
7195               {
7196                 case 0x00:
7197                   op_semantics_48:
7198                     {
7199                       /** 1111 1100 0001 01ss rsrc rdst min     %1%S1, %0 */
7200 #line 564 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7201                       int ss AU = op[1] & 0x03;
7202 #line 564 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7203                       int rsrc AU = (op[2] >> 4) & 0x0f;
7204 #line 564 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7205                       int rdst AU = op[2] & 0x0f;
7206                       if (trace)
7207                         {
7208                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7209                                  "/** 1111 1100 0001 01ss rsrc rdst     min     %1%S1, %0 */",
7210                                  op[0], op[1], op[2]);
7211                           printf ("  ss = 0x%x,", ss);
7212                           printf ("  rsrc = 0x%x,", rsrc);
7213                           printf ("  rdst = 0x%x\n", rdst);
7214                         }
7215                       SYNTAX("min       %1%S1, %0");
7216 #line 565 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7217                       ID(min); SP(ss, rsrc); DR(rdst);
7218
7219                     }
7220                   break;
7221               }
7222             break;
7223           case 0x15:
7224               GETBYTE ();
7225               switch (op[2] & 0x00)
7226               {
7227                 case 0x00:
7228                   goto op_semantics_48;
7229                   break;
7230               }
7231             break;
7232           case 0x16:
7233               GETBYTE ();
7234               switch (op[2] & 0x00)
7235               {
7236                 case 0x00:
7237                   goto op_semantics_48;
7238                   break;
7239               }
7240             break;
7241           case 0x17:
7242               GETBYTE ();
7243               switch (op[2] & 0x00)
7244               {
7245                 case 0x00:
7246                   goto op_semantics_48;
7247                   break;
7248               }
7249             break;
7250           case 0x18:
7251               GETBYTE ();
7252               switch (op[2] & 0x00)
7253               {
7254                 case 0x00:
7255                   op_semantics_49:
7256                     {
7257                       /** 1111 1100 0001 10ss rsrc rdst emul    %1%S1, %0 */
7258 #line 594 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7259                       int ss AU = op[1] & 0x03;
7260 #line 594 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7261                       int rsrc AU = (op[2] >> 4) & 0x0f;
7262 #line 594 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7263                       int rdst AU = op[2] & 0x0f;
7264                       if (trace)
7265                         {
7266                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7267                                  "/** 1111 1100 0001 10ss rsrc rdst     emul    %1%S1, %0 */",
7268                                  op[0], op[1], op[2]);
7269                           printf ("  ss = 0x%x,", ss);
7270                           printf ("  rsrc = 0x%x,", rsrc);
7271                           printf ("  rdst = 0x%x\n", rdst);
7272                         }
7273                       SYNTAX("emul      %1%S1, %0");
7274 #line 595 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7275                       ID(emul); SP(ss, rsrc); DR(rdst);
7276
7277                     }
7278                   break;
7279               }
7280             break;
7281           case 0x19:
7282               GETBYTE ();
7283               switch (op[2] & 0x00)
7284               {
7285                 case 0x00:
7286                   goto op_semantics_49;
7287                   break;
7288               }
7289             break;
7290           case 0x1a:
7291               GETBYTE ();
7292               switch (op[2] & 0x00)
7293               {
7294                 case 0x00:
7295                   goto op_semantics_49;
7296                   break;
7297               }
7298             break;
7299           case 0x1b:
7300               GETBYTE ();
7301               switch (op[2] & 0x00)
7302               {
7303                 case 0x00:
7304                   goto op_semantics_49;
7305                   break;
7306               }
7307             break;
7308           case 0x1c:
7309               GETBYTE ();
7310               switch (op[2] & 0x00)
7311               {
7312                 case 0x00:
7313                   op_semantics_50:
7314                     {
7315                       /** 1111 1100 0001 11ss rsrc rdst emulu   %1%S1, %0 */
7316 #line 606 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7317                       int ss AU = op[1] & 0x03;
7318 #line 606 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7319                       int rsrc AU = (op[2] >> 4) & 0x0f;
7320 #line 606 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7321                       int rdst AU = op[2] & 0x0f;
7322                       if (trace)
7323                         {
7324                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7325                                  "/** 1111 1100 0001 11ss rsrc rdst     emulu   %1%S1, %0 */",
7326                                  op[0], op[1], op[2]);
7327                           printf ("  ss = 0x%x,", ss);
7328                           printf ("  rsrc = 0x%x,", rsrc);
7329                           printf ("  rdst = 0x%x\n", rdst);
7330                         }
7331                       SYNTAX("emulu     %1%S1, %0");
7332 #line 607 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7333                       ID(emulu); SP(ss, rsrc); DR(rdst);
7334
7335                     }
7336                   break;
7337               }
7338             break;
7339           case 0x1d:
7340               GETBYTE ();
7341               switch (op[2] & 0x00)
7342               {
7343                 case 0x00:
7344                   goto op_semantics_50;
7345                   break;
7346               }
7347             break;
7348           case 0x1e:
7349               GETBYTE ();
7350               switch (op[2] & 0x00)
7351               {
7352                 case 0x00:
7353                   goto op_semantics_50;
7354                   break;
7355               }
7356             break;
7357           case 0x1f:
7358               GETBYTE ();
7359               switch (op[2] & 0x00)
7360               {
7361                 case 0x00:
7362                   goto op_semantics_50;
7363                   break;
7364               }
7365             break;
7366           case 0x20:
7367               GETBYTE ();
7368               switch (op[2] & 0x00)
7369               {
7370                 case 0x00:
7371                   op_semantics_51:
7372                     {
7373                       /** 1111 1100 0010 00ss rsrc rdst div     %1%S1, %0 */
7374 #line 618 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7375                       int ss AU = op[1] & 0x03;
7376 #line 618 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7377                       int rsrc AU = (op[2] >> 4) & 0x0f;
7378 #line 618 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7379                       int rdst AU = op[2] & 0x0f;
7380                       if (trace)
7381                         {
7382                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7383                                  "/** 1111 1100 0010 00ss rsrc rdst     div     %1%S1, %0 */",
7384                                  op[0], op[1], op[2]);
7385                           printf ("  ss = 0x%x,", ss);
7386                           printf ("  rsrc = 0x%x,", rsrc);
7387                           printf ("  rdst = 0x%x\n", rdst);
7388                         }
7389                       SYNTAX("div       %1%S1, %0");
7390 #line 619 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7391                       ID(div); SP(ss, rsrc); DR(rdst); F("O---");
7392
7393                     }
7394                   break;
7395               }
7396             break;
7397           case 0x21:
7398               GETBYTE ();
7399               switch (op[2] & 0x00)
7400               {
7401                 case 0x00:
7402                   goto op_semantics_51;
7403                   break;
7404               }
7405             break;
7406           case 0x22:
7407               GETBYTE ();
7408               switch (op[2] & 0x00)
7409               {
7410                 case 0x00:
7411                   goto op_semantics_51;
7412                   break;
7413               }
7414             break;
7415           case 0x23:
7416               GETBYTE ();
7417               switch (op[2] & 0x00)
7418               {
7419                 case 0x00:
7420                   goto op_semantics_51;
7421                   break;
7422               }
7423             break;
7424           case 0x24:
7425               GETBYTE ();
7426               switch (op[2] & 0x00)
7427               {
7428                 case 0x00:
7429                   op_semantics_52:
7430                     {
7431                       /** 1111 1100 0010 01ss rsrc rdst divu    %1%S1, %0 */
7432 #line 630 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7433                       int ss AU = op[1] & 0x03;
7434 #line 630 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7435                       int rsrc AU = (op[2] >> 4) & 0x0f;
7436 #line 630 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7437                       int rdst AU = op[2] & 0x0f;
7438                       if (trace)
7439                         {
7440                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7441                                  "/** 1111 1100 0010 01ss rsrc rdst     divu    %1%S1, %0 */",
7442                                  op[0], op[1], op[2]);
7443                           printf ("  ss = 0x%x,", ss);
7444                           printf ("  rsrc = 0x%x,", rsrc);
7445                           printf ("  rdst = 0x%x\n", rdst);
7446                         }
7447                       SYNTAX("divu      %1%S1, %0");
7448 #line 631 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7449                       ID(divu); SP(ss, rsrc); DR(rdst); F("O---");
7450
7451                     }
7452                   break;
7453               }
7454             break;
7455           case 0x25:
7456               GETBYTE ();
7457               switch (op[2] & 0x00)
7458               {
7459                 case 0x00:
7460                   goto op_semantics_52;
7461                   break;
7462               }
7463             break;
7464           case 0x26:
7465               GETBYTE ();
7466               switch (op[2] & 0x00)
7467               {
7468                 case 0x00:
7469                   goto op_semantics_52;
7470                   break;
7471               }
7472             break;
7473           case 0x27:
7474               GETBYTE ();
7475               switch (op[2] & 0x00)
7476               {
7477                 case 0x00:
7478                   goto op_semantics_52;
7479                   break;
7480               }
7481             break;
7482           case 0x30:
7483               GETBYTE ();
7484               switch (op[2] & 0x00)
7485               {
7486                 case 0x00:
7487                   op_semantics_53:
7488                     {
7489                       /** 1111 1100 0011 00ss rsrc rdst tst     %1%S1, %2 */
7490 #line 449 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7491                       int ss AU = op[1] & 0x03;
7492 #line 449 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7493                       int rsrc AU = (op[2] >> 4) & 0x0f;
7494 #line 449 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7495                       int rdst AU = op[2] & 0x0f;
7496                       if (trace)
7497                         {
7498                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7499                                  "/** 1111 1100 0011 00ss rsrc rdst     tst     %1%S1, %2 */",
7500                                  op[0], op[1], op[2]);
7501                           printf ("  ss = 0x%x,", ss);
7502                           printf ("  rsrc = 0x%x,", rsrc);
7503                           printf ("  rdst = 0x%x\n", rdst);
7504                         }
7505                       SYNTAX("tst       %1%S1, %2");
7506 #line 450 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7507                       ID(and); SP(ss, rsrc); S2R(rdst); F("-SZ-");
7508
7509                     }
7510                   break;
7511               }
7512             break;
7513           case 0x31:
7514               GETBYTE ();
7515               switch (op[2] & 0x00)
7516               {
7517                 case 0x00:
7518                   goto op_semantics_53;
7519                   break;
7520               }
7521             break;
7522           case 0x32:
7523               GETBYTE ();
7524               switch (op[2] & 0x00)
7525               {
7526                 case 0x00:
7527                   goto op_semantics_53;
7528                   break;
7529               }
7530             break;
7531           case 0x33:
7532               GETBYTE ();
7533               switch (op[2] & 0x00)
7534               {
7535                 case 0x00:
7536                   goto op_semantics_53;
7537                   break;
7538               }
7539             break;
7540           case 0x34:
7541               GETBYTE ();
7542               switch (op[2] & 0x00)
7543               {
7544                 case 0x00:
7545                   op_semantics_54:
7546                     {
7547                       /** 1111 1100 0011 01ss rsrc rdst xor     %1%S1, %0 */
7548 #line 428 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7549                       int ss AU = op[1] & 0x03;
7550 #line 428 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7551                       int rsrc AU = (op[2] >> 4) & 0x0f;
7552 #line 428 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7553                       int rdst AU = op[2] & 0x0f;
7554                       if (trace)
7555                         {
7556                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7557                                  "/** 1111 1100 0011 01ss rsrc rdst     xor     %1%S1, %0 */",
7558                                  op[0], op[1], op[2]);
7559                           printf ("  ss = 0x%x,", ss);
7560                           printf ("  rsrc = 0x%x,", rsrc);
7561                           printf ("  rdst = 0x%x\n", rdst);
7562                         }
7563                       SYNTAX("xor       %1%S1, %0");
7564 #line 429 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7565                       ID(xor); SP(ss, rsrc); DR(rdst); F("-SZ-");
7566
7567                     }
7568                   break;
7569               }
7570             break;
7571           case 0x35:
7572               GETBYTE ();
7573               switch (op[2] & 0x00)
7574               {
7575                 case 0x00:
7576                   goto op_semantics_54;
7577                   break;
7578               }
7579             break;
7580           case 0x36:
7581               GETBYTE ();
7582               switch (op[2] & 0x00)
7583               {
7584                 case 0x00:
7585                   goto op_semantics_54;
7586                   break;
7587               }
7588             break;
7589           case 0x37:
7590               GETBYTE ();
7591               switch (op[2] & 0x00)
7592               {
7593                 case 0x00:
7594                   goto op_semantics_54;
7595                   break;
7596               }
7597             break;
7598           case 0x3b:
7599               GETBYTE ();
7600               switch (op[2] & 0x00)
7601               {
7602                 case 0x00:
7603                     {
7604                       /** 1111 1100 0011 1011 rsrc rdst not     %1, %0 */
7605 #line 440 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7606                       int rsrc AU = (op[2] >> 4) & 0x0f;
7607 #line 440 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7608                       int rdst AU = op[2] & 0x0f;
7609                       if (trace)
7610                         {
7611                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7612                                  "/** 1111 1100 0011 1011 rsrc rdst     not     %1, %0 */",
7613                                  op[0], op[1], op[2]);
7614                           printf ("  rsrc = 0x%x,", rsrc);
7615                           printf ("  rdst = 0x%x\n", rdst);
7616                         }
7617                       SYNTAX("not       %1, %0");
7618 #line 441 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7619                       ID(xor); DR(rdst); SR(rsrc); S2C(~0); F("-SZ-");
7620
7621                     /*----------------------------------------------------------------------*/
7622                     /* TST                                                                      */
7623
7624                     }
7625                   break;
7626               }
7627             break;
7628           case 0x40:
7629               GETBYTE ();
7630               switch (op[2] & 0x00)
7631               {
7632                 case 0x00:
7633                   op_semantics_55:
7634                     {
7635                       /** 1111 1100 0100 00ss rsrc rdst xchg    %1%S1, %0 */
7636 #line 362 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7637                       int ss AU = op[1] & 0x03;
7638 #line 362 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7639                       int rsrc AU = (op[2] >> 4) & 0x0f;
7640 #line 362 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7641                       int rdst AU = op[2] & 0x0f;
7642                       if (trace)
7643                         {
7644                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7645                                  "/** 1111 1100 0100 00ss rsrc rdst     xchg    %1%S1, %0 */",
7646                                  op[0], op[1], op[2]);
7647                           printf ("  ss = 0x%x,", ss);
7648                           printf ("  rsrc = 0x%x,", rsrc);
7649                           printf ("  rdst = 0x%x\n", rdst);
7650                         }
7651                       SYNTAX("xchg      %1%S1, %0");
7652 #line 363 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7653                       ID(xchg); DR(rdst); SP(ss, rsrc);
7654
7655                     }
7656                   break;
7657               }
7658             break;
7659           case 0x41:
7660               GETBYTE ();
7661               switch (op[2] & 0x00)
7662               {
7663                 case 0x00:
7664                   goto op_semantics_55;
7665                   break;
7666               }
7667             break;
7668           case 0x42:
7669               GETBYTE ();
7670               switch (op[2] & 0x00)
7671               {
7672                 case 0x00:
7673                   goto op_semantics_55;
7674                   break;
7675               }
7676             break;
7677           case 0x43:
7678               GETBYTE ();
7679               switch (op[2] & 0x00)
7680               {
7681                 case 0x00:
7682                   goto op_semantics_55;
7683                   break;
7684               }
7685             break;
7686           case 0x44:
7687               GETBYTE ();
7688               switch (op[2] & 0x00)
7689               {
7690                 case 0x00:
7691                   op_semantics_56:
7692                     {
7693                       /** 1111 1100 0100 01sd rsrc rdst itof    %1%S1, %0 */
7694 #line 859 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7695                       int sd AU = op[1] & 0x03;
7696 #line 859 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7697                       int rsrc AU = (op[2] >> 4) & 0x0f;
7698 #line 859 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7699                       int rdst AU = op[2] & 0x0f;
7700                       if (trace)
7701                         {
7702                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7703                                  "/** 1111 1100 0100 01sd rsrc rdst     itof    %1%S1, %0 */",
7704                                  op[0], op[1], op[2]);
7705                           printf ("  sd = 0x%x,", sd);
7706                           printf ("  rsrc = 0x%x,", rsrc);
7707                           printf ("  rdst = 0x%x\n", rdst);
7708                         }
7709                       SYNTAX("itof      %1%S1, %0");
7710 #line 860 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7711                       ID(itof); DR (rdst); SP(sd, rsrc); F("-SZ-");
7712
7713                     }
7714                   break;
7715               }
7716             break;
7717           case 0x45:
7718               GETBYTE ();
7719               switch (op[2] & 0x00)
7720               {
7721                 case 0x00:
7722                   goto op_semantics_56;
7723                   break;
7724               }
7725             break;
7726           case 0x46:
7727               GETBYTE ();
7728               switch (op[2] & 0x00)
7729               {
7730                 case 0x00:
7731                   goto op_semantics_56;
7732                   break;
7733               }
7734             break;
7735           case 0x47:
7736               GETBYTE ();
7737               switch (op[2] & 0x00)
7738               {
7739                 case 0x00:
7740                   goto op_semantics_56;
7741                   break;
7742               }
7743             break;
7744           case 0x60:
7745               GETBYTE ();
7746               switch (op[2] & 0x00)
7747               {
7748                 case 0x00:
7749                   op_semantics_57:
7750                     {
7751                       /** 1111 1100 0110 00sd rdst rsrc bset    %1, %0%S0 */
7752 #line 871 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7753                       int sd AU = op[1] & 0x03;
7754 #line 871 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7755                       int rdst AU = (op[2] >> 4) & 0x0f;
7756 #line 871 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7757                       int rsrc AU = op[2] & 0x0f;
7758                       if (trace)
7759                         {
7760                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7761                                  "/** 1111 1100 0110 00sd rdst rsrc     bset    %1, %0%S0 */",
7762                                  op[0], op[1], op[2]);
7763                           printf ("  sd = 0x%x,", sd);
7764                           printf ("  rdst = 0x%x,", rdst);
7765                           printf ("  rsrc = 0x%x\n", rsrc);
7766                         }
7767                       SYNTAX("bset      %1, %0%S0");
7768 #line 872 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7769                       ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F("----");
7770
7771                     }
7772                   break;
7773               }
7774             break;
7775           case 0x61:
7776               GETBYTE ();
7777               switch (op[2] & 0x00)
7778               {
7779                 case 0x00:
7780                   goto op_semantics_57;
7781                   break;
7782               }
7783             break;
7784           case 0x62:
7785               GETBYTE ();
7786               switch (op[2] & 0x00)
7787               {
7788                 case 0x00:
7789                   goto op_semantics_57;
7790                   break;
7791               }
7792             break;
7793           case 0x63:
7794               GETBYTE ();
7795               switch (op[2] & 0x00)
7796               {
7797                 case 0x00:
7798                   goto op_semantics_57;
7799                   break;
7800               }
7801             break;
7802           case 0x64:
7803               GETBYTE ();
7804               switch (op[2] & 0x00)
7805               {
7806                 case 0x00:
7807                   op_semantics_58:
7808                     {
7809                       /** 1111 1100 0110 01sd rdst rsrc bclr    %1, %0%S0 */
7810 #line 881 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7811                       int sd AU = op[1] & 0x03;
7812 #line 881 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7813                       int rdst AU = (op[2] >> 4) & 0x0f;
7814 #line 881 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7815                       int rsrc AU = op[2] & 0x0f;
7816                       if (trace)
7817                         {
7818                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7819                                  "/** 1111 1100 0110 01sd rdst rsrc     bclr    %1, %0%S0 */",
7820                                  op[0], op[1], op[2]);
7821                           printf ("  sd = 0x%x,", sd);
7822                           printf ("  rdst = 0x%x,", rdst);
7823                           printf ("  rsrc = 0x%x\n", rsrc);
7824                         }
7825                       SYNTAX("bclr      %1, %0%S0");
7826 #line 882 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7827                       ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F("----");
7828
7829                     }
7830                   break;
7831               }
7832             break;
7833           case 0x65:
7834               GETBYTE ();
7835               switch (op[2] & 0x00)
7836               {
7837                 case 0x00:
7838                   goto op_semantics_58;
7839                   break;
7840               }
7841             break;
7842           case 0x66:
7843               GETBYTE ();
7844               switch (op[2] & 0x00)
7845               {
7846                 case 0x00:
7847                   goto op_semantics_58;
7848                   break;
7849               }
7850             break;
7851           case 0x67:
7852               GETBYTE ();
7853               switch (op[2] & 0x00)
7854               {
7855                 case 0x00:
7856                   goto op_semantics_58;
7857                   break;
7858               }
7859             break;
7860           case 0x68:
7861               GETBYTE ();
7862               switch (op[2] & 0x00)
7863               {
7864                 case 0x00:
7865                   op_semantics_59:
7866                     {
7867                       /** 1111 1100 0110 10sd rdst rsrc btst    %2, %1%S1 */
7868 #line 891 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7869                       int sd AU = op[1] & 0x03;
7870 #line 891 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7871                       int rdst AU = (op[2] >> 4) & 0x0f;
7872 #line 891 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7873                       int rsrc AU = op[2] & 0x0f;
7874                       if (trace)
7875                         {
7876                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7877                                  "/** 1111 1100 0110 10sd rdst rsrc     btst    %2, %1%S1 */",
7878                                  op[0], op[1], op[2]);
7879                           printf ("  sd = 0x%x,", sd);
7880                           printf ("  rdst = 0x%x,", rdst);
7881                           printf ("  rsrc = 0x%x\n", rsrc);
7882                         }
7883                       SYNTAX("btst      %2, %1%S1");
7884 #line 892 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7885                       ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F("--ZC");
7886
7887                     }
7888                   break;
7889               }
7890             break;
7891           case 0x69:
7892               GETBYTE ();
7893               switch (op[2] & 0x00)
7894               {
7895                 case 0x00:
7896                   goto op_semantics_59;
7897                   break;
7898               }
7899             break;
7900           case 0x6a:
7901               GETBYTE ();
7902               switch (op[2] & 0x00)
7903               {
7904                 case 0x00:
7905                   goto op_semantics_59;
7906                   break;
7907               }
7908             break;
7909           case 0x6b:
7910               GETBYTE ();
7911               switch (op[2] & 0x00)
7912               {
7913                 case 0x00:
7914                   goto op_semantics_59;
7915                   break;
7916               }
7917             break;
7918           case 0x6c:
7919               GETBYTE ();
7920               switch (op[2] & 0x00)
7921               {
7922                 case 0x00:
7923                   op_semantics_60:
7924                     {
7925                       /** 1111 1100 0110 11sd rdst rsrc bnot    %1, %0%S0 */
7926 #line 901 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7927                       int sd AU = op[1] & 0x03;
7928 #line 901 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7929                       int rdst AU = (op[2] >> 4) & 0x0f;
7930 #line 901 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7931                       int rsrc AU = op[2] & 0x0f;
7932                       if (trace)
7933                         {
7934                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7935                                  "/** 1111 1100 0110 11sd rdst rsrc     bnot    %1, %0%S0 */",
7936                                  op[0], op[1], op[2]);
7937                           printf ("  sd = 0x%x,", sd);
7938                           printf ("  rdst = 0x%x,", rdst);
7939                           printf ("  rsrc = 0x%x\n", rsrc);
7940                         }
7941                       SYNTAX("bnot      %1, %0%S0");
7942 #line 902 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7943                       ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE);
7944
7945                     }
7946                   break;
7947               }
7948             break;
7949           case 0x6d:
7950               GETBYTE ();
7951               switch (op[2] & 0x00)
7952               {
7953                 case 0x00:
7954                   goto op_semantics_60;
7955                   break;
7956               }
7957             break;
7958           case 0x6e:
7959               GETBYTE ();
7960               switch (op[2] & 0x00)
7961               {
7962                 case 0x00:
7963                   goto op_semantics_60;
7964                   break;
7965               }
7966             break;
7967           case 0x6f:
7968               GETBYTE ();
7969               switch (op[2] & 0x00)
7970               {
7971                 case 0x00:
7972                   goto op_semantics_60;
7973                   break;
7974               }
7975             break;
7976           case 0x80:
7977               GETBYTE ();
7978               switch (op[2] & 0x00)
7979               {
7980                 case 0x00:
7981                   op_semantics_61:
7982                     {
7983                       /** 1111 1100 1000 00sd rsrc rdst fsub    %1%S1, %0 */
7984 #line 838 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7985                       int sd AU = op[1] & 0x03;
7986 #line 838 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7987                       int rsrc AU = (op[2] >> 4) & 0x0f;
7988 #line 838 "/work/sources/gcc/current/opcodes/rx-decode.opc"
7989                       int rdst AU = op[2] & 0x0f;
7990                       if (trace)
7991                         {
7992                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7993                                  "/** 1111 1100 1000 00sd rsrc rdst     fsub    %1%S1, %0 */",
7994                                  op[0], op[1], op[2]);
7995                           printf ("  sd = 0x%x,", sd);
7996                           printf ("  rsrc = 0x%x,", rsrc);
7997                           printf ("  rdst = 0x%x\n", rdst);
7998                         }
7999                       SYNTAX("fsub      %1%S1, %0");
8000 #line 839 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8001                       ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F("-SZ-");
8002
8003                     }
8004                   break;
8005               }
8006             break;
8007           case 0x81:
8008               GETBYTE ();
8009               switch (op[2] & 0x00)
8010               {
8011                 case 0x00:
8012                   goto op_semantics_61;
8013                   break;
8014               }
8015             break;
8016           case 0x82:
8017               GETBYTE ();
8018               switch (op[2] & 0x00)
8019               {
8020                 case 0x00:
8021                   goto op_semantics_61;
8022                   break;
8023               }
8024             break;
8025           case 0x83:
8026               GETBYTE ();
8027               switch (op[2] & 0x00)
8028               {
8029                 case 0x00:
8030                   goto op_semantics_61;
8031                   break;
8032               }
8033             break;
8034           case 0x84:
8035               GETBYTE ();
8036               switch (op[2] & 0x00)
8037               {
8038                 case 0x00:
8039                   op_semantics_62:
8040                     {
8041                       /** 1111 1100 1000 01sd rsrc rdst fcmp    %1%S1, %0 */
8042 #line 832 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8043                       int sd AU = op[1] & 0x03;
8044 #line 832 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8045                       int rsrc AU = (op[2] >> 4) & 0x0f;
8046 #line 832 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8047                       int rdst AU = op[2] & 0x0f;
8048                       if (trace)
8049                         {
8050                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8051                                  "/** 1111 1100 1000 01sd rsrc rdst     fcmp    %1%S1, %0 */",
8052                                  op[0], op[1], op[2]);
8053                           printf ("  sd = 0x%x,", sd);
8054                           printf ("  rsrc = 0x%x,", rsrc);
8055                           printf ("  rdst = 0x%x\n", rdst);
8056                         }
8057                       SYNTAX("fcmp      %1%S1, %0");
8058 #line 833 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8059                       ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F("OSZ-");
8060
8061                     }
8062                   break;
8063               }
8064             break;
8065           case 0x85:
8066               GETBYTE ();
8067               switch (op[2] & 0x00)
8068               {
8069                 case 0x00:
8070                   goto op_semantics_62;
8071                   break;
8072               }
8073             break;
8074           case 0x86:
8075               GETBYTE ();
8076               switch (op[2] & 0x00)
8077               {
8078                 case 0x00:
8079                   goto op_semantics_62;
8080                   break;
8081               }
8082             break;
8083           case 0x87:
8084               GETBYTE ();
8085               switch (op[2] & 0x00)
8086               {
8087                 case 0x00:
8088                   goto op_semantics_62;
8089                   break;
8090               }
8091             break;
8092           case 0x88:
8093               GETBYTE ();
8094               switch (op[2] & 0x00)
8095               {
8096                 case 0x00:
8097                   op_semantics_63:
8098                     {
8099                       /** 1111 1100 1000 10sd rsrc rdst fadd    %1%S1, %0 */
8100 #line 826 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8101                       int sd AU = op[1] & 0x03;
8102 #line 826 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8103                       int rsrc AU = (op[2] >> 4) & 0x0f;
8104 #line 826 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8105                       int rdst AU = op[2] & 0x0f;
8106                       if (trace)
8107                         {
8108                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8109                                  "/** 1111 1100 1000 10sd rsrc rdst     fadd    %1%S1, %0 */",
8110                                  op[0], op[1], op[2]);
8111                           printf ("  sd = 0x%x,", sd);
8112                           printf ("  rsrc = 0x%x,", rsrc);
8113                           printf ("  rdst = 0x%x\n", rdst);
8114                         }
8115                       SYNTAX("fadd      %1%S1, %0");
8116 #line 827 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8117                       ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F("-SZ-");
8118
8119                     }
8120                   break;
8121               }
8122             break;
8123           case 0x89:
8124               GETBYTE ();
8125               switch (op[2] & 0x00)
8126               {
8127                 case 0x00:
8128                   goto op_semantics_63;
8129                   break;
8130               }
8131             break;
8132           case 0x8a:
8133               GETBYTE ();
8134               switch (op[2] & 0x00)
8135               {
8136                 case 0x00:
8137                   goto op_semantics_63;
8138                   break;
8139               }
8140             break;
8141           case 0x8b:
8142               GETBYTE ();
8143               switch (op[2] & 0x00)
8144               {
8145                 case 0x00:
8146                   goto op_semantics_63;
8147                   break;
8148               }
8149             break;
8150           case 0x8c:
8151               GETBYTE ();
8152               switch (op[2] & 0x00)
8153               {
8154                 case 0x00:
8155                   op_semantics_64:
8156                     {
8157                       /** 1111 1100 1000 11sd rsrc rdst fmul    %1%S1, %0 */
8158 #line 847 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8159                       int sd AU = op[1] & 0x03;
8160 #line 847 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8161                       int rsrc AU = (op[2] >> 4) & 0x0f;
8162 #line 847 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8163                       int rdst AU = op[2] & 0x0f;
8164                       if (trace)
8165                         {
8166                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8167                                  "/** 1111 1100 1000 11sd rsrc rdst     fmul    %1%S1, %0 */",
8168                                  op[0], op[1], op[2]);
8169                           printf ("  sd = 0x%x,", sd);
8170                           printf ("  rsrc = 0x%x,", rsrc);
8171                           printf ("  rdst = 0x%x\n", rdst);
8172                         }
8173                       SYNTAX("fmul      %1%S1, %0");
8174 #line 848 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8175                       ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F("-SZ-");
8176
8177                     }
8178                   break;
8179               }
8180             break;
8181           case 0x8d:
8182               GETBYTE ();
8183               switch (op[2] & 0x00)
8184               {
8185                 case 0x00:
8186                   goto op_semantics_64;
8187                   break;
8188               }
8189             break;
8190           case 0x8e:
8191               GETBYTE ();
8192               switch (op[2] & 0x00)
8193               {
8194                 case 0x00:
8195                   goto op_semantics_64;
8196                   break;
8197               }
8198             break;
8199           case 0x8f:
8200               GETBYTE ();
8201               switch (op[2] & 0x00)
8202               {
8203                 case 0x00:
8204                   goto op_semantics_64;
8205                   break;
8206               }
8207             break;
8208           case 0x90:
8209               GETBYTE ();
8210               switch (op[2] & 0x00)
8211               {
8212                 case 0x00:
8213                   op_semantics_65:
8214                     {
8215                       /** 1111 1100 1001 00sd rsrc rdst fdiv    %1%S1, %0 */
8216 #line 853 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8217                       int sd AU = op[1] & 0x03;
8218 #line 853 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8219                       int rsrc AU = (op[2] >> 4) & 0x0f;
8220 #line 853 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8221                       int rdst AU = op[2] & 0x0f;
8222                       if (trace)
8223                         {
8224                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8225                                  "/** 1111 1100 1001 00sd rsrc rdst     fdiv    %1%S1, %0 */",
8226                                  op[0], op[1], op[2]);
8227                           printf ("  sd = 0x%x,", sd);
8228                           printf ("  rsrc = 0x%x,", rsrc);
8229                           printf ("  rdst = 0x%x\n", rdst);
8230                         }
8231                       SYNTAX("fdiv      %1%S1, %0");
8232 #line 854 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8233                       ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F("-SZ-");
8234
8235                     }
8236                   break;
8237               }
8238             break;
8239           case 0x91:
8240               GETBYTE ();
8241               switch (op[2] & 0x00)
8242               {
8243                 case 0x00:
8244                   goto op_semantics_65;
8245                   break;
8246               }
8247             break;
8248           case 0x92:
8249               GETBYTE ();
8250               switch (op[2] & 0x00)
8251               {
8252                 case 0x00:
8253                   goto op_semantics_65;
8254                   break;
8255               }
8256             break;
8257           case 0x93:
8258               GETBYTE ();
8259               switch (op[2] & 0x00)
8260               {
8261                 case 0x00:
8262                   goto op_semantics_65;
8263                   break;
8264               }
8265             break;
8266           case 0x94:
8267               GETBYTE ();
8268               switch (op[2] & 0x00)
8269               {
8270                 case 0x00:
8271                   op_semantics_66:
8272                     {
8273                       /** 1111 1100 1001 01sd rsrc rdst ftoi    %1%S1, %0 */
8274 #line 841 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8275                       int sd AU = op[1] & 0x03;
8276 #line 841 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8277                       int rsrc AU = (op[2] >> 4) & 0x0f;
8278 #line 841 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8279                       int rdst AU = op[2] & 0x0f;
8280                       if (trace)
8281                         {
8282                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8283                                  "/** 1111 1100 1001 01sd rsrc rdst     ftoi    %1%S1, %0 */",
8284                                  op[0], op[1], op[2]);
8285                           printf ("  sd = 0x%x,", sd);
8286                           printf ("  rsrc = 0x%x,", rsrc);
8287                           printf ("  rdst = 0x%x\n", rdst);
8288                         }
8289                       SYNTAX("ftoi      %1%S1, %0");
8290 #line 842 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8291                       ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F("-SZ-");
8292
8293                     }
8294                   break;
8295               }
8296             break;
8297           case 0x95:
8298               GETBYTE ();
8299               switch (op[2] & 0x00)
8300               {
8301                 case 0x00:
8302                   goto op_semantics_66;
8303                   break;
8304               }
8305             break;
8306           case 0x96:
8307               GETBYTE ();
8308               switch (op[2] & 0x00)
8309               {
8310                 case 0x00:
8311                   goto op_semantics_66;
8312                   break;
8313               }
8314             break;
8315           case 0x97:
8316               GETBYTE ();
8317               switch (op[2] & 0x00)
8318               {
8319                 case 0x00:
8320                   goto op_semantics_66;
8321                   break;
8322               }
8323             break;
8324           case 0x98:
8325               GETBYTE ();
8326               switch (op[2] & 0x00)
8327               {
8328                 case 0x00:
8329                   op_semantics_67:
8330                     {
8331                       /** 1111 1100 1001 10sd rsrc rdst round   %1%S1, %0 */
8332 #line 856 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8333                       int sd AU = op[1] & 0x03;
8334 #line 856 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8335                       int rsrc AU = (op[2] >> 4) & 0x0f;
8336 #line 856 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8337                       int rdst AU = op[2] & 0x0f;
8338                       if (trace)
8339                         {
8340                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8341                                  "/** 1111 1100 1001 10sd rsrc rdst     round   %1%S1, %0 */",
8342                                  op[0], op[1], op[2]);
8343                           printf ("  sd = 0x%x,", sd);
8344                           printf ("  rsrc = 0x%x,", rsrc);
8345                           printf ("  rdst = 0x%x\n", rdst);
8346                         }
8347                       SYNTAX("round     %1%S1, %0");
8348 #line 857 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8349                       ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F("-SZ-");
8350
8351                     }
8352                   break;
8353               }
8354             break;
8355           case 0x99:
8356               GETBYTE ();
8357               switch (op[2] & 0x00)
8358               {
8359                 case 0x00:
8360                   goto op_semantics_67;
8361                   break;
8362               }
8363             break;
8364           case 0x9a:
8365               GETBYTE ();
8366               switch (op[2] & 0x00)
8367               {
8368                 case 0x00:
8369                   goto op_semantics_67;
8370                   break;
8371               }
8372             break;
8373           case 0x9b:
8374               GETBYTE ();
8375               switch (op[2] & 0x00)
8376               {
8377                 case 0x00:
8378                   goto op_semantics_67;
8379                   break;
8380               }
8381             break;
8382           case 0xd0:
8383               GETBYTE ();
8384               switch (op[2] & 0x00)
8385               {
8386                 case 0x00:
8387                   op_semantics_68:
8388                     {
8389                       /** 1111 1100 1101 sz sd rdst cond        sc%1%s  %0 */
8390 #line 971 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8391                       int sz AU = (op[1] >> 2) & 0x03;
8392 #line 971 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8393                       int sd AU = op[1] & 0x03;
8394 #line 971 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8395                       int rdst AU = (op[2] >> 4) & 0x0f;
8396 #line 971 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8397                       int cond AU = op[2] & 0x0f;
8398                       if (trace)
8399                         {
8400                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8401                                  "/** 1111 1100 1101 sz sd rdst cond    sc%1%s  %0 */",
8402                                  op[0], op[1], op[2]);
8403                           printf ("  sz = 0x%x,", sz);
8404                           printf ("  sd = 0x%x,", sd);
8405                           printf ("  rdst = 0x%x,", rdst);
8406                           printf ("  cond = 0x%x\n", cond);
8407                         }
8408                       SYNTAX("sc%1%s    %0");
8409 #line 972 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8410                       ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond);
8411
8412                     }
8413                   break;
8414               }
8415             break;
8416           case 0xd1:
8417               GETBYTE ();
8418               switch (op[2] & 0x00)
8419               {
8420                 case 0x00:
8421                   goto op_semantics_68;
8422                   break;
8423               }
8424             break;
8425           case 0xd2:
8426               GETBYTE ();
8427               switch (op[2] & 0x00)
8428               {
8429                 case 0x00:
8430                   goto op_semantics_68;
8431                   break;
8432               }
8433             break;
8434           case 0xd3:
8435               GETBYTE ();
8436               switch (op[2] & 0x00)
8437               {
8438                 case 0x00:
8439                   goto op_semantics_68;
8440                   break;
8441               }
8442             break;
8443           case 0xd4:
8444               GETBYTE ();
8445               switch (op[2] & 0x00)
8446               {
8447                 case 0x00:
8448                   goto op_semantics_68;
8449                   break;
8450               }
8451             break;
8452           case 0xd5:
8453               GETBYTE ();
8454               switch (op[2] & 0x00)
8455               {
8456                 case 0x00:
8457                   goto op_semantics_68;
8458                   break;
8459               }
8460             break;
8461           case 0xd6:
8462               GETBYTE ();
8463               switch (op[2] & 0x00)
8464               {
8465                 case 0x00:
8466                   goto op_semantics_68;
8467                   break;
8468               }
8469             break;
8470           case 0xd7:
8471               GETBYTE ();
8472               switch (op[2] & 0x00)
8473               {
8474                 case 0x00:
8475                   goto op_semantics_68;
8476                   break;
8477               }
8478             break;
8479           case 0xd8:
8480               GETBYTE ();
8481               switch (op[2] & 0x00)
8482               {
8483                 case 0x00:
8484                   goto op_semantics_68;
8485                   break;
8486               }
8487             break;
8488           case 0xd9:
8489               GETBYTE ();
8490               switch (op[2] & 0x00)
8491               {
8492                 case 0x00:
8493                   goto op_semantics_68;
8494                   break;
8495               }
8496             break;
8497           case 0xda:
8498               GETBYTE ();
8499               switch (op[2] & 0x00)
8500               {
8501                 case 0x00:
8502                   goto op_semantics_68;
8503                   break;
8504               }
8505             break;
8506           case 0xdb:
8507               GETBYTE ();
8508               switch (op[2] & 0x00)
8509               {
8510                 case 0x00:
8511                   goto op_semantics_68;
8512                   break;
8513               }
8514             break;
8515           case 0xe0:
8516               GETBYTE ();
8517               switch (op[2] & 0x0f)
8518               {
8519                 case 0x00:
8520                 case 0x01:
8521                 case 0x02:
8522                 case 0x03:
8523                 case 0x04:
8524                 case 0x05:
8525                 case 0x06:
8526                 case 0x07:
8527                 case 0x08:
8528                 case 0x09:
8529                 case 0x0a:
8530                 case 0x0b:
8531                 case 0x0c:
8532                 case 0x0d:
8533                 case 0x0e:
8534                   op_semantics_69:
8535                     {
8536                       /** 1111 1100 111bit sd rdst cond bm%2    #%1, %0%S0 */
8537 #line 908 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8538                       int bit AU = (op[1] >> 2) & 0x07;
8539 #line 908 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8540                       int sd AU = op[1] & 0x03;
8541 #line 908 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8542                       int rdst AU = (op[2] >> 4) & 0x0f;
8543 #line 908 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8544                       int cond AU = op[2] & 0x0f;
8545                       if (trace)
8546                         {
8547                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8548                                  "/** 1111 1100 111bit sd rdst cond     bm%2    #%1, %0%S0 */",
8549                                  op[0], op[1], op[2]);
8550                           printf ("  bit = 0x%x,", bit);
8551                           printf ("  sd = 0x%x,", sd);
8552                           printf ("  rdst = 0x%x,", rdst);
8553                           printf ("  cond = 0x%x\n", cond);
8554                         }
8555                       SYNTAX("bm%2      #%1, %0%S0");
8556 #line 909 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8557                       ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE);
8558
8559                     }
8560                   break;
8561                 case 0x0f:
8562                   op_semantics_70:
8563                     {
8564                       /** 1111 1100 111bit sd rdst 1111 bnot    #%1, %0%S0 */
8565 #line 898 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8566                       int bit AU = (op[1] >> 2) & 0x07;
8567 #line 898 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8568                       int sd AU = op[1] & 0x03;
8569 #line 898 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8570                       int rdst AU = (op[2] >> 4) & 0x0f;
8571                       if (trace)
8572                         {
8573                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8574                                  "/** 1111 1100 111bit sd rdst 1111     bnot    #%1, %0%S0 */",
8575                                  op[0], op[1], op[2]);
8576                           printf ("  bit = 0x%x,", bit);
8577                           printf ("  sd = 0x%x,", sd);
8578                           printf ("  rdst = 0x%x\n", rdst);
8579                         }
8580                       SYNTAX("bnot      #%1, %0%S0");
8581 #line 899 "/work/sources/gcc/current/opcodes/rx-decode.opc"
8582                       ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE);
8583
8584                     }
8585                   break;
8586               }
8587             break;
8588           case 0xe1:
8589               GETBYTE ();
8590               switch (op[2] & 0x0f)
8591               {
8592                 case 0x00:
8593                 case 0x01:
8594                 case 0x02:
8595                 case 0x03:
8596                 case 0x04:
8597                 case 0x05:
8598                 case 0x06:
8599                 case 0x07:
8600                 case 0x08:
8601                 case 0x09:
8602                 case 0x0a:
8603                 case 0x0b:
8604                 case 0x0c:
8605                 case 0x0d:
8606                 case 0x0e:
8607                   goto op_semantics_69;
8608                   break;
8609                 case 0x0f:
8610                   goto op_semantics_70;
8611                   break;
8612               }
8613             break;
8614           case 0xe2:
8615               GETBYTE ();
8616               switch (op[2] & 0x0f)
8617               {
8618                 case 0x00:
8619                 case 0x01:
8620                 case 0x02:
8621                 case 0x03:
8622                 case 0x04:
8623                 case 0x05:
8624                 case 0x06:
8625                 case 0x07:
8626                 case 0x08:
8627                 case 0x09:
8628                 case 0x0a:
8629                 case 0x0b:
8630                 case 0x0c:
8631                 case 0x0d:
8632                 case 0x0e:
8633                   goto op_semantics_69;
8634                   break;
8635                 case 0x0f:
8636                   goto op_semantics_70;
8637                   break;
8638               }
8639             break;
8640           case 0xe3:
8641               GETBYTE ();
8642               switch (op[2] & 0x0f)
8643               {
8644                 case 0x00:
8645                 case 0x01:
8646                 case 0x02:
8647                 case 0x03:
8648                 case 0x04:
8649                 case 0x05:
8650                 case 0x06:
8651                 case 0x07:
8652                 case 0x08:
8653                 case 0x09:
8654                 case 0x0a:
8655                 case 0x0b:
8656                 case 0x0c:
8657                 case 0x0d:
8658                 case 0x0e:
8659                   goto op_semantics_69;
8660                   break;
8661                 case 0x0f:
8662                   goto op_semantics_70;
8663                   break;
8664               }
8665             break;
8666           case 0xe4:
8667               GETBYTE ();
8668               switch (op[2] & 0x0f)
8669               {
8670                 case 0x00:
8671                 case 0x01:
8672                 case 0x02:
8673                 case 0x03:
8674                 case 0x04:
8675                 case 0x05:
8676                 case 0x06:
8677                 case 0x07:
8678                 case 0x08:
8679                 case 0x09:
8680                 case 0x0a:
8681                 case 0x0b:
8682                 case 0x0c:
8683                 case 0x0d:
8684                 case 0x0e:
8685                   goto op_semantics_69;
8686                   break;
8687                 case 0x0f:
8688                   goto op_semantics_70;
8689                   break;
8690               }
8691             break;
8692           case 0xe5:
8693               GETBYTE ();
8694               switch (op[2] & 0x0f)
8695               {
8696                 case 0x00:
8697                 case 0x01:
8698                 case 0x02:
8699                 case 0x03:
8700                 case 0x04:
8701                 case 0x05:
8702                 case 0x06:
8703                 case 0x07:
8704                 case 0x08:
8705                 case 0x09:
8706                 case 0x0a:
8707                 case 0x0b:
8708                 case 0x0c:
8709                 case 0x0d:
8710                 case 0x0e:
8711                   goto op_semantics_69;
8712                   break;
8713                 case 0x0f:
8714                   goto op_semantics_70;
8715                   break;
8716               }
8717             break;
8718           case 0xe6:
8719               GETBYTE ();
8720               switch (op[2] & 0x0f)
8721               {
8722                 case 0x00:
8723                 case 0x01:
8724                 case 0x02:
8725                 case 0x03:
8726                 case 0x04:
8727                 case 0x05:
8728                 case 0x06:
8729                 case 0x07:
8730                 case 0x08:
8731                 case 0x09:
8732                 case 0x0a:
8733                 case 0x0b:
8734                 case 0x0c:
8735                 case 0x0d:
8736                 case 0x0e:
8737                   goto op_semantics_69;
8738                   break;
8739                 case 0x0f:
8740                   goto op_semantics_70;
8741                   break;
8742               }
8743             break;
8744           case 0xe7:
8745               GETBYTE ();
8746               switch (op[2] & 0x0f)
8747               {
8748                 case 0x00:
8749                 case 0x01:
8750                 case 0x02:
8751                 case 0x03:
8752                 case 0x04:
8753                 case 0x05:
8754                 case 0x06:
8755                 case 0x07:
8756                 case 0x08:
8757                 case 0x09:
8758                 case 0x0a:
8759                 case 0x0b:
8760                 case 0x0c:
8761                 case 0x0d:
8762                 case 0x0e:
8763                   goto op_semantics_69;
8764                   break;
8765                 case 0x0f:
8766                   goto op_semantics_70;
8767                   break;
8768               }
8769             break;
8770           case 0xe8:
8771               GETBYTE ();
8772               switch (op[2] & 0x0f)
8773               {
8774                 case 0x00:
8775                 case 0x01:
8776                 case 0x02:
8777                 case 0x03:
8778                 case 0x04:
8779                 case 0x05:
8780                 case 0x06:
8781                 case 0x07:
8782                 case 0x08:
8783                 case 0x09:
8784                 case 0x0a:
8785                 case 0x0b:
8786                 case 0x0c:
8787                 case 0x0d:
8788                 case 0x0e:
8789                   goto op_semantics_69;
8790                   break;
8791                 case 0x0f:
8792                   goto op_semantics_70;
8793                   break;
8794               }
8795             break;
8796           case 0xe9:
8797               GETBYTE ();
8798               switch (op[2] & 0x0f)
8799               {
8800                 case 0x00:
8801                 case 0x01:
8802                 case 0x02:
8803                 case 0x03:
8804                 case 0x04:
8805                 case 0x05:
8806                 case 0x06:
8807                 case 0x07:
8808                 case 0x08:
8809                 case 0x09:
8810                 case 0x0a:
8811                 case 0x0b:
8812                 case 0x0c:
8813                 case 0x0d:
8814                 case 0x0e:
8815                   goto op_semantics_69;
8816                   break;
8817                 case 0x0f:
8818                   goto op_semantics_70;
8819                   break;
8820               }
8821             break;
8822           case 0xea:
8823               GETBYTE ();
8824               switch (op[2] & 0x0f)
8825               {
8826                 case 0x00:
8827                 case 0x01:
8828                 case 0x02:
8829                 case 0x03:
8830                 case 0x04:
8831                 case 0x05:
8832                 case 0x06:
8833                 case 0x07:
8834                 case 0x08:
8835                 case 0x09:
8836                 case 0x0a:
8837                 case 0x0b:
8838                 case 0x0c:
8839                 case 0x0d:
8840                 case 0x0e:
8841                   goto op_semantics_69;
8842                   break;
8843                 case 0x0f:
8844                   goto op_semantics_70;
8845                   break;
8846               }
8847             break;
8848           case 0xeb:
8849               GETBYTE ();
8850               switch (op[2] & 0x0f)
8851               {
8852                 case 0x00:
8853                 case 0x01:
8854                 case 0x02:
8855                 case 0x03:
8856                 case 0x04:
8857                 case 0x05:
8858                 case 0x06:
8859                 case 0x07:
8860                 case 0x08:
8861                 case 0x09:
8862                 case 0x0a:
8863                 case 0x0b:
8864                 case 0x0c:
8865                 case 0x0d:
8866                 case 0x0e:
8867                   goto op_semantics_69;
8868                   break;
8869                 case 0x0f:
8870                   goto op_semantics_70;
8871                   break;
8872               }
8873             break;
8874           case 0xec:
8875               GETBYTE ();
8876               switch (op[2] & 0x0f)
8877               {
8878                 case 0x00:
8879                 case 0x01:
8880                 case 0x02:
8881                 case 0x03:
8882                 case 0x04:
8883                 case 0x05:
8884                 case 0x06:
8885                 case 0x07:
8886                 case 0x08:
8887                 case 0x09:
8888                 case 0x0a:
8889                 case 0x0b:
8890                 case 0x0c:
8891                 case 0x0d:
8892                 case 0x0e:
8893                   goto op_semantics_69;
8894                   break;
8895                 case 0x0f:
8896                   goto op_semantics_70;
8897                   break;
8898               }
8899             break;
8900           case 0xed:
8901               GETBYTE ();
8902               switch (op[2] & 0x0f)
8903               {
8904                 case 0x00:
8905                 case 0x01:
8906                 case 0x02:
8907                 case 0x03:
8908                 case 0x04:
8909                 case 0x05:
8910                 case 0x06:
8911                 case 0x07:
8912                 case 0x08:
8913                 case 0x09:
8914                 case 0x0a:
8915                 case 0x0b:
8916                 case 0x0c:
8917                 case 0x0d:
8918                 case 0x0e:
8919                   goto op_semantics_69;
8920                   break;
8921                 case 0x0f:
8922                   goto op_semantics_70;
8923                   break;
8924               }
8925             break;
8926           case 0xee:
8927               GETBYTE ();
8928               switch (op[2] & 0x0f)
8929               {
8930                 case 0x00:
8931                 case 0x01:
8932                 case 0x02:
8933                 case 0x03:
8934                 case 0x04:
8935                 case 0x05:
8936                 case 0x06:
8937                 case 0x07:
8938                 case 0x08:
8939                 case 0x09:
8940                 case 0x0a:
8941                 case 0x0b:
8942                 case 0x0c:
8943                 case 0x0d:
8944                 case 0x0e:
8945                   goto op_semantics_69;
8946                   break;
8947                 case 0x0f:
8948                   goto op_semantics_70;
8949                   break;
8950               }
8951             break;
8952           case 0xef:
8953               GETBYTE ();
8954               switch (op[2] & 0x0f)
8955               {
8956                 case 0x00:
8957                 case 0x01:
8958                 case 0x02:
8959                 case 0x03:
8960                 case 0x04:
8961                 case 0x05:
8962                 case 0x06:
8963                 case 0x07:
8964                 case 0x08:
8965                 case 0x09:
8966                 case 0x0a:
8967                 case 0x0b:
8968                 case 0x0c:
8969                 case 0x0d:
8970                 case 0x0e:
8971                   goto op_semantics_69;
8972                   break;
8973                 case 0x0f:
8974                   goto op_semantics_70;
8975                   break;
8976               }
8977             break;
8978           case 0xf0:
8979               GETBYTE ();
8980               switch (op[2] & 0x0f)
8981               {
8982                 case 0x00:
8983                 case 0x01:
8984                 case 0x02:
8985                 case 0x03:
8986                 case 0x04:
8987                 case 0x05:
8988                 case 0x06:
8989                 case 0x07:
8990                 case 0x08:
8991                 case 0x09:
8992                 case 0x0a:
8993                 case 0x0b:
8994                 case 0x0c:
8995                 case 0x0d:
8996                 case 0x0e:
8997                   goto op_semantics_69;
8998                   break;
8999                 case 0x0f:
9000                   goto op_semantics_70;
9001                   break;
9002               }
9003             break;
9004           case 0xf1:
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                   goto op_semantics_69;
9024                   break;
9025                 case 0x0f:
9026                   goto op_semantics_70;
9027                   break;
9028               }
9029             break;
9030           case 0xf2:
9031               GETBYTE ();
9032               switch (op[2] & 0x0f)
9033               {
9034                 case 0x00:
9035                 case 0x01:
9036                 case 0x02:
9037                 case 0x03:
9038                 case 0x04:
9039                 case 0x05:
9040                 case 0x06:
9041                 case 0x07:
9042                 case 0x08:
9043                 case 0x09:
9044                 case 0x0a:
9045                 case 0x0b:
9046                 case 0x0c:
9047                 case 0x0d:
9048                 case 0x0e:
9049                   goto op_semantics_69;
9050                   break;
9051                 case 0x0f:
9052                   goto op_semantics_70;
9053                   break;
9054               }
9055             break;
9056           case 0xf3:
9057               GETBYTE ();
9058               switch (op[2] & 0x0f)
9059               {
9060                 case 0x00:
9061                 case 0x01:
9062                 case 0x02:
9063                 case 0x03:
9064                 case 0x04:
9065                 case 0x05:
9066                 case 0x06:
9067                 case 0x07:
9068                 case 0x08:
9069                 case 0x09:
9070                 case 0x0a:
9071                 case 0x0b:
9072                 case 0x0c:
9073                 case 0x0d:
9074                 case 0x0e:
9075                   goto op_semantics_69;
9076                   break;
9077                 case 0x0f:
9078                   goto op_semantics_70;
9079                   break;
9080               }
9081             break;
9082           case 0xf4:
9083               GETBYTE ();
9084               switch (op[2] & 0x0f)
9085               {
9086                 case 0x00:
9087                 case 0x01:
9088                 case 0x02:
9089                 case 0x03:
9090                 case 0x04:
9091                 case 0x05:
9092                 case 0x06:
9093                 case 0x07:
9094                 case 0x08:
9095                 case 0x09:
9096                 case 0x0a:
9097                 case 0x0b:
9098                 case 0x0c:
9099                 case 0x0d:
9100                 case 0x0e:
9101                   goto op_semantics_69;
9102                   break;
9103                 case 0x0f:
9104                   goto op_semantics_70;
9105                   break;
9106               }
9107             break;
9108           case 0xf5:
9109               GETBYTE ();
9110               switch (op[2] & 0x0f)
9111               {
9112                 case 0x00:
9113                 case 0x01:
9114                 case 0x02:
9115                 case 0x03:
9116                 case 0x04:
9117                 case 0x05:
9118                 case 0x06:
9119                 case 0x07:
9120                 case 0x08:
9121                 case 0x09:
9122                 case 0x0a:
9123                 case 0x0b:
9124                 case 0x0c:
9125                 case 0x0d:
9126                 case 0x0e:
9127                   goto op_semantics_69;
9128                   break;
9129                 case 0x0f:
9130                   goto op_semantics_70;
9131                   break;
9132               }
9133             break;
9134           case 0xf6:
9135               GETBYTE ();
9136               switch (op[2] & 0x0f)
9137               {
9138                 case 0x00:
9139                 case 0x01:
9140                 case 0x02:
9141                 case 0x03:
9142                 case 0x04:
9143                 case 0x05:
9144                 case 0x06:
9145                 case 0x07:
9146                 case 0x08:
9147                 case 0x09:
9148                 case 0x0a:
9149                 case 0x0b:
9150                 case 0x0c:
9151                 case 0x0d:
9152                 case 0x0e:
9153                   goto op_semantics_69;
9154                   break;
9155                 case 0x0f:
9156                   goto op_semantics_70;
9157                   break;
9158               }
9159             break;
9160           case 0xf7:
9161               GETBYTE ();
9162               switch (op[2] & 0x0f)
9163               {
9164                 case 0x00:
9165                 case 0x01:
9166                 case 0x02:
9167                 case 0x03:
9168                 case 0x04:
9169                 case 0x05:
9170                 case 0x06:
9171                 case 0x07:
9172                 case 0x08:
9173                 case 0x09:
9174                 case 0x0a:
9175                 case 0x0b:
9176                 case 0x0c:
9177                 case 0x0d:
9178                 case 0x0e:
9179                   goto op_semantics_69;
9180                   break;
9181                 case 0x0f:
9182                   goto op_semantics_70;
9183                   break;
9184               }
9185             break;
9186           case 0xf8:
9187               GETBYTE ();
9188               switch (op[2] & 0x0f)
9189               {
9190                 case 0x00:
9191                 case 0x01:
9192                 case 0x02:
9193                 case 0x03:
9194                 case 0x04:
9195                 case 0x05:
9196                 case 0x06:
9197                 case 0x07:
9198                 case 0x08:
9199                 case 0x09:
9200                 case 0x0a:
9201                 case 0x0b:
9202                 case 0x0c:
9203                 case 0x0d:
9204                 case 0x0e:
9205                   goto op_semantics_69;
9206                   break;
9207                 case 0x0f:
9208                   goto op_semantics_70;
9209                   break;
9210               }
9211             break;
9212           case 0xf9:
9213               GETBYTE ();
9214               switch (op[2] & 0x0f)
9215               {
9216                 case 0x00:
9217                 case 0x01:
9218                 case 0x02:
9219                 case 0x03:
9220                 case 0x04:
9221                 case 0x05:
9222                 case 0x06:
9223                 case 0x07:
9224                 case 0x08:
9225                 case 0x09:
9226                 case 0x0a:
9227                 case 0x0b:
9228                 case 0x0c:
9229                 case 0x0d:
9230                 case 0x0e:
9231                   goto op_semantics_69;
9232                   break;
9233                 case 0x0f:
9234                   goto op_semantics_70;
9235                   break;
9236               }
9237             break;
9238           case 0xfa:
9239               GETBYTE ();
9240               switch (op[2] & 0x0f)
9241               {
9242                 case 0x00:
9243                 case 0x01:
9244                 case 0x02:
9245                 case 0x03:
9246                 case 0x04:
9247                 case 0x05:
9248                 case 0x06:
9249                 case 0x07:
9250                 case 0x08:
9251                 case 0x09:
9252                 case 0x0a:
9253                 case 0x0b:
9254                 case 0x0c:
9255                 case 0x0d:
9256                 case 0x0e:
9257                   goto op_semantics_69;
9258                   break;
9259                 case 0x0f:
9260                   goto op_semantics_70;
9261                   break;
9262               }
9263             break;
9264           case 0xfb:
9265               GETBYTE ();
9266               switch (op[2] & 0x0f)
9267               {
9268                 case 0x00:
9269                 case 0x01:
9270                 case 0x02:
9271                 case 0x03:
9272                 case 0x04:
9273                 case 0x05:
9274                 case 0x06:
9275                 case 0x07:
9276                 case 0x08:
9277                 case 0x09:
9278                 case 0x0a:
9279                 case 0x0b:
9280                 case 0x0c:
9281                 case 0x0d:
9282                 case 0x0e:
9283                   goto op_semantics_69;
9284                   break;
9285                 case 0x0f:
9286                   goto op_semantics_70;
9287                   break;
9288               }
9289             break;
9290           case 0xfc:
9291               GETBYTE ();
9292               switch (op[2] & 0x0f)
9293               {
9294                 case 0x00:
9295                 case 0x01:
9296                 case 0x02:
9297                 case 0x03:
9298                 case 0x04:
9299                 case 0x05:
9300                 case 0x06:
9301                 case 0x07:
9302                 case 0x08:
9303                 case 0x09:
9304                 case 0x0a:
9305                 case 0x0b:
9306                 case 0x0c:
9307                 case 0x0d:
9308                 case 0x0e:
9309                   goto op_semantics_69;
9310                   break;
9311                 case 0x0f:
9312                   goto op_semantics_70;
9313                   break;
9314               }
9315             break;
9316           case 0xfd:
9317               GETBYTE ();
9318               switch (op[2] & 0x0f)
9319               {
9320                 case 0x00:
9321                 case 0x01:
9322                 case 0x02:
9323                 case 0x03:
9324                 case 0x04:
9325                 case 0x05:
9326                 case 0x06:
9327                 case 0x07:
9328                 case 0x08:
9329                 case 0x09:
9330                 case 0x0a:
9331                 case 0x0b:
9332                 case 0x0c:
9333                 case 0x0d:
9334                 case 0x0e:
9335                   goto op_semantics_69;
9336                   break;
9337                 case 0x0f:
9338                   goto op_semantics_70;
9339                   break;
9340               }
9341             break;
9342           case 0xfe:
9343               GETBYTE ();
9344               switch (op[2] & 0x0f)
9345               {
9346                 case 0x00:
9347                 case 0x01:
9348                 case 0x02:
9349                 case 0x03:
9350                 case 0x04:
9351                 case 0x05:
9352                 case 0x06:
9353                 case 0x07:
9354                 case 0x08:
9355                 case 0x09:
9356                 case 0x0a:
9357                 case 0x0b:
9358                 case 0x0c:
9359                 case 0x0d:
9360                 case 0x0e:
9361                   goto op_semantics_69;
9362                   break;
9363                 case 0x0f:
9364                   goto op_semantics_70;
9365                   break;
9366               }
9367             break;
9368           case 0xff:
9369               GETBYTE ();
9370               switch (op[2] & 0x0f)
9371               {
9372                 case 0x00:
9373                 case 0x01:
9374                 case 0x02:
9375                 case 0x03:
9376                 case 0x04:
9377                 case 0x05:
9378                 case 0x06:
9379                 case 0x07:
9380                 case 0x08:
9381                 case 0x09:
9382                 case 0x0a:
9383                 case 0x0b:
9384                 case 0x0c:
9385                 case 0x0d:
9386                 case 0x0e:
9387                   goto op_semantics_69;
9388                   break;
9389                 case 0x0f:
9390                   goto op_semantics_70;
9391                   break;
9392               }
9393             break;
9394           default: UNSUPPORTED(); break;
9395         }
9396       break;
9397     case 0xfd:
9398         GETBYTE ();
9399         switch (op[1] & 0xff)
9400         {
9401           case 0x00:
9402               GETBYTE ();
9403               switch (op[2] & 0x00)
9404               {
9405                 case 0x00:
9406                     {
9407                       /** 1111 1101 0000 0000 srca srcb mulhi   %1, %2 */
9408 #line 781 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9409                       int srca AU = (op[2] >> 4) & 0x0f;
9410 #line 781 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9411                       int srcb AU = op[2] & 0x0f;
9412                       if (trace)
9413                         {
9414                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9415                                  "/** 1111 1101 0000 0000 srca srcb     mulhi   %1, %2 */",
9416                                  op[0], op[1], op[2]);
9417                           printf ("  srca = 0x%x,", srca);
9418                           printf ("  srcb = 0x%x\n", srcb);
9419                         }
9420                       SYNTAX("mulhi     %1, %2");
9421 #line 782 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9422                       ID(mulhi); SR(srca); S2R(srcb); F("----");
9423
9424                     }
9425                   break;
9426               }
9427             break;
9428           case 0x01:
9429               GETBYTE ();
9430               switch (op[2] & 0x00)
9431               {
9432                 case 0x00:
9433                     {
9434                       /** 1111 1101 0000 0001 srca srcb mullo   %1, %2 */
9435 #line 784 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9436                       int srca AU = (op[2] >> 4) & 0x0f;
9437 #line 784 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9438                       int srcb AU = op[2] & 0x0f;
9439                       if (trace)
9440                         {
9441                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9442                                  "/** 1111 1101 0000 0001 srca srcb     mullo   %1, %2 */",
9443                                  op[0], op[1], op[2]);
9444                           printf ("  srca = 0x%x,", srca);
9445                           printf ("  srcb = 0x%x\n", srcb);
9446                         }
9447                       SYNTAX("mullo     %1, %2");
9448 #line 785 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9449                       ID(mullo); SR(srca); S2R(srcb); F("----");
9450
9451                     }
9452                   break;
9453               }
9454             break;
9455           case 0x04:
9456               GETBYTE ();
9457               switch (op[2] & 0x00)
9458               {
9459                 case 0x00:
9460                     {
9461                       /** 1111 1101 0000 0100 srca srcb machi   %1, %2 */
9462 #line 787 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9463                       int srca AU = (op[2] >> 4) & 0x0f;
9464 #line 787 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9465                       int srcb AU = op[2] & 0x0f;
9466                       if (trace)
9467                         {
9468                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9469                                  "/** 1111 1101 0000 0100 srca srcb     machi   %1, %2 */",
9470                                  op[0], op[1], op[2]);
9471                           printf ("  srca = 0x%x,", srca);
9472                           printf ("  srcb = 0x%x\n", srcb);
9473                         }
9474                       SYNTAX("machi     %1, %2");
9475 #line 788 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9476                       ID(machi); SR(srca); S2R(srcb); F("----");
9477
9478                     }
9479                   break;
9480               }
9481             break;
9482           case 0x05:
9483               GETBYTE ();
9484               switch (op[2] & 0x00)
9485               {
9486                 case 0x00:
9487                     {
9488                       /** 1111 1101 0000 0101 srca srcb maclo   %1, %2 */
9489 #line 790 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9490                       int srca AU = (op[2] >> 4) & 0x0f;
9491 #line 790 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9492                       int srcb AU = op[2] & 0x0f;
9493                       if (trace)
9494                         {
9495                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9496                                  "/** 1111 1101 0000 0101 srca srcb     maclo   %1, %2 */",
9497                                  op[0], op[1], op[2]);
9498                           printf ("  srca = 0x%x,", srca);
9499                           printf ("  srcb = 0x%x\n", srcb);
9500                         }
9501                       SYNTAX("maclo     %1, %2");
9502 #line 791 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9503                       ID(maclo); SR(srca); S2R(srcb); F("----");
9504
9505                     }
9506                   break;
9507               }
9508             break;
9509           case 0x17:
9510               GETBYTE ();
9511               switch (op[2] & 0xf0)
9512               {
9513                 case 0x00:
9514                     {
9515                       /** 1111 1101 0001 0111 0000 rsrc mvtachi %1 */
9516 #line 793 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9517                       int rsrc AU = op[2] & 0x0f;
9518                       if (trace)
9519                         {
9520                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9521                                  "/** 1111 1101 0001 0111 0000 rsrc     mvtachi %1 */",
9522                                  op[0], op[1], op[2]);
9523                           printf ("  rsrc = 0x%x\n", rsrc);
9524                         }
9525                       SYNTAX("mvtachi   %1");
9526 #line 794 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9527                       ID(mvtachi); SR(rsrc); F("----");
9528
9529                     }
9530                   break;
9531                 case 0x10:
9532                     {
9533                       /** 1111 1101 0001 0111 0001 rsrc mvtaclo %1 */
9534 #line 796 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9535                       int rsrc AU = op[2] & 0x0f;
9536                       if (trace)
9537                         {
9538                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9539                                  "/** 1111 1101 0001 0111 0001 rsrc     mvtaclo %1 */",
9540                                  op[0], op[1], op[2]);
9541                           printf ("  rsrc = 0x%x\n", rsrc);
9542                         }
9543                       SYNTAX("mvtaclo   %1");
9544 #line 797 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9545                       ID(mvtaclo); SR(rsrc); F("----");
9546
9547                     }
9548                   break;
9549                 default: UNSUPPORTED(); break;
9550               }
9551             break;
9552           case 0x18:
9553               GETBYTE ();
9554               switch (op[2] & 0xef)
9555               {
9556                 case 0x00:
9557                     {
9558                       /** 1111 1101 0001 1000 000i 0000 racw    #%1 */
9559 #line 808 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9560                       int i AU = (op[2] >> 4) & 0x01;
9561                       if (trace)
9562                         {
9563                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9564                                  "/** 1111 1101 0001 1000 000i 0000     racw    #%1 */",
9565                                  op[0], op[1], op[2]);
9566                           printf ("  i = 0x%x\n", i);
9567                         }
9568                       SYNTAX("racw      #%1");
9569 #line 809 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9570                       ID(racw); SC(i+1); F("----");
9571
9572                     /*----------------------------------------------------------------------*/
9573                     /* SAT                                                                      */
9574
9575                     }
9576                   break;
9577                 default: UNSUPPORTED(); break;
9578               }
9579             break;
9580           case 0x1f:
9581               GETBYTE ();
9582               switch (op[2] & 0xf0)
9583               {
9584                 case 0x00:
9585                     {
9586                       /** 1111 1101 0001 1111 0000 rdst mvfachi %0 */
9587 #line 799 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9588                       int rdst AU = op[2] & 0x0f;
9589                       if (trace)
9590                         {
9591                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9592                                  "/** 1111 1101 0001 1111 0000 rdst     mvfachi %0 */",
9593                                  op[0], op[1], op[2]);
9594                           printf ("  rdst = 0x%x\n", rdst);
9595                         }
9596                       SYNTAX("mvfachi   %0");
9597 #line 800 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9598                       ID(mvfachi); DR(rdst); F("----");
9599
9600                     }
9601                   break;
9602                 case 0x10:
9603                     {
9604                       /** 1111 1101 0001 1111 0001 rdst mvfaclo %0 */
9605 #line 805 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9606                       int rdst AU = op[2] & 0x0f;
9607                       if (trace)
9608                         {
9609                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9610                                  "/** 1111 1101 0001 1111 0001 rdst     mvfaclo %0 */",
9611                                  op[0], op[1], op[2]);
9612                           printf ("  rdst = 0x%x\n", rdst);
9613                         }
9614                       SYNTAX("mvfaclo   %0");
9615 #line 806 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9616                       ID(mvfaclo); DR(rdst); F("----");
9617
9618                     }
9619                   break;
9620                 case 0x20:
9621                     {
9622                       /** 1111 1101 0001 1111 0010 rdst mvfacmi %0 */
9623 #line 802 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9624                       int rdst AU = op[2] & 0x0f;
9625                       if (trace)
9626                         {
9627                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9628                                  "/** 1111 1101 0001 1111 0010 rdst     mvfacmi %0 */",
9629                                  op[0], op[1], op[2]);
9630                           printf ("  rdst = 0x%x\n", rdst);
9631                         }
9632                       SYNTAX("mvfacmi   %0");
9633 #line 803 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9634                       ID(mvfacmi); DR(rdst); F("----");
9635
9636                     }
9637                   break;
9638                 default: UNSUPPORTED(); break;
9639               }
9640             break;
9641           case 0x20:
9642               GETBYTE ();
9643               switch (op[2] & 0x00)
9644               {
9645                 case 0x00:
9646                   op_semantics_71:
9647                     {
9648                       /** 1111 1101 0010 0p sz rdst rsrc        mov%s   %1, %0 */
9649 #line 323 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9650                       int p AU = (op[1] >> 2) & 0x01;
9651 #line 323 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9652                       int sz AU = op[1] & 0x03;
9653 #line 323 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9654                       int rdst AU = (op[2] >> 4) & 0x0f;
9655 #line 323 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9656                       int rsrc AU = op[2] & 0x0f;
9657                       if (trace)
9658                         {
9659                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9660                                  "/** 1111 1101 0010 0p sz rdst rsrc    mov%s   %1, %0 */",
9661                                  op[0], op[1], op[2]);
9662                           printf ("  p = 0x%x,", p);
9663                           printf ("  sz = 0x%x,", sz);
9664                           printf ("  rdst = 0x%x,", rdst);
9665                           printf ("  rsrc = 0x%x\n", rsrc);
9666                         }
9667                       SYNTAX("mov%s     %1, %0");
9668 #line 324 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9669                       ID(mov); sBWL (sz); SR(rsrc); F("----");
9670                       OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0);
9671
9672                     }
9673                   break;
9674               }
9675             break;
9676           case 0x21:
9677               GETBYTE ();
9678               switch (op[2] & 0x00)
9679               {
9680                 case 0x00:
9681                   goto op_semantics_71;
9682                   break;
9683               }
9684             break;
9685           case 0x22:
9686               GETBYTE ();
9687               switch (op[2] & 0x00)
9688               {
9689                 case 0x00:
9690                   goto op_semantics_71;
9691                   break;
9692               }
9693             break;
9694           case 0x24:
9695               GETBYTE ();
9696               switch (op[2] & 0x00)
9697               {
9698                 case 0x00:
9699                   goto op_semantics_71;
9700                   break;
9701               }
9702             break;
9703           case 0x25:
9704               GETBYTE ();
9705               switch (op[2] & 0x00)
9706               {
9707                 case 0x00:
9708                   goto op_semantics_71;
9709                   break;
9710               }
9711             break;
9712           case 0x26:
9713               GETBYTE ();
9714               switch (op[2] & 0x00)
9715               {
9716                 case 0x00:
9717                   goto op_semantics_71;
9718                   break;
9719               }
9720             break;
9721           case 0x28:
9722               GETBYTE ();
9723               switch (op[2] & 0x00)
9724               {
9725                 case 0x00:
9726                   op_semantics_72:
9727                     {
9728                       /** 1111 1101 0010 1p sz rsrc rdst        mov%s   %1, %0 */
9729 #line 327 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9730                       int p AU = (op[1] >> 2) & 0x01;
9731 #line 327 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9732                       int sz AU = op[1] & 0x03;
9733 #line 327 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9734                       int rsrc AU = (op[2] >> 4) & 0x0f;
9735 #line 327 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9736                       int rdst AU = op[2] & 0x0f;
9737                       if (trace)
9738                         {
9739                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9740                                  "/** 1111 1101 0010 1p sz rsrc rdst    mov%s   %1, %0 */",
9741                                  op[0], op[1], op[2]);
9742                           printf ("  p = 0x%x,", p);
9743                           printf ("  sz = 0x%x,", sz);
9744                           printf ("  rsrc = 0x%x,", rsrc);
9745                           printf ("  rdst = 0x%x\n", rdst);
9746                         }
9747                       SYNTAX("mov%s     %1, %0");
9748 #line 328 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9749                       ID(mov); sBWL (sz); DR(rdst); F("----");
9750                       OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
9751
9752                     }
9753                   break;
9754               }
9755             break;
9756           case 0x29:
9757               GETBYTE ();
9758               switch (op[2] & 0x00)
9759               {
9760                 case 0x00:
9761                   goto op_semantics_72;
9762                   break;
9763               }
9764             break;
9765           case 0x2a:
9766               GETBYTE ();
9767               switch (op[2] & 0x00)
9768               {
9769                 case 0x00:
9770                   goto op_semantics_72;
9771                   break;
9772               }
9773             break;
9774           case 0x2c:
9775               GETBYTE ();
9776               switch (op[2] & 0x00)
9777               {
9778                 case 0x00:
9779                   goto op_semantics_72;
9780                   break;
9781               }
9782             break;
9783           case 0x2d:
9784               GETBYTE ();
9785               switch (op[2] & 0x00)
9786               {
9787                 case 0x00:
9788                   goto op_semantics_72;
9789                   break;
9790               }
9791             break;
9792           case 0x2e:
9793               GETBYTE ();
9794               switch (op[2] & 0x00)
9795               {
9796                 case 0x00:
9797                   goto op_semantics_72;
9798                   break;
9799               }
9800             break;
9801           case 0x38:
9802               GETBYTE ();
9803               switch (op[2] & 0x00)
9804               {
9805                 case 0x00:
9806                   op_semantics_73:
9807                     {
9808                       /** 1111 1101 0011 1p sz rsrc rdst        movu%s  %1, %0 */
9809 #line 337 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9810                       int p AU = (op[1] >> 2) & 0x01;
9811 #line 337 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9812                       int sz AU = op[1] & 0x03;
9813 #line 337 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9814                       int rsrc AU = (op[2] >> 4) & 0x0f;
9815 #line 337 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9816                       int rdst AU = op[2] & 0x0f;
9817                       if (trace)
9818                         {
9819                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9820                                  "/** 1111 1101 0011 1p sz rsrc rdst    movu%s  %1, %0 */",
9821                                  op[0], op[1], op[2]);
9822                           printf ("  p = 0x%x,", p);
9823                           printf ("  sz = 0x%x,", sz);
9824                           printf ("  rsrc = 0x%x,", rsrc);
9825                           printf ("  rdst = 0x%x\n", rdst);
9826                         }
9827                       SYNTAX("movu%s    %1, %0");
9828 #line 338 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9829                       ID(mov); uBWL (sz); DR(rdst); F("----");
9830                        OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
9831
9832                     /*----------------------------------------------------------------------*/
9833                     /* PUSH/POP                                                         */
9834
9835                     }
9836                   break;
9837               }
9838             break;
9839           case 0x39:
9840               GETBYTE ();
9841               switch (op[2] & 0x00)
9842               {
9843                 case 0x00:
9844                   goto op_semantics_73;
9845                   break;
9846               }
9847             break;
9848           case 0x3a:
9849               GETBYTE ();
9850               switch (op[2] & 0x00)
9851               {
9852                 case 0x00:
9853                   goto op_semantics_73;
9854                   break;
9855               }
9856             break;
9857           case 0x3c:
9858               GETBYTE ();
9859               switch (op[2] & 0x00)
9860               {
9861                 case 0x00:
9862                   goto op_semantics_73;
9863                   break;
9864               }
9865             break;
9866           case 0x3d:
9867               GETBYTE ();
9868               switch (op[2] & 0x00)
9869               {
9870                 case 0x00:
9871                   goto op_semantics_73;
9872                   break;
9873               }
9874             break;
9875           case 0x3e:
9876               GETBYTE ();
9877               switch (op[2] & 0x00)
9878               {
9879                 case 0x00:
9880                   goto op_semantics_73;
9881                   break;
9882               }
9883             break;
9884           case 0x60:
9885               GETBYTE ();
9886               switch (op[2] & 0x00)
9887               {
9888                 case 0x00:
9889                     {
9890                       /** 1111 1101 0110 0000 rsrc rdst shlr    %2, %0 */
9891 #line 662 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9892                       int rsrc AU = (op[2] >> 4) & 0x0f;
9893 #line 662 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9894                       int rdst AU = op[2] & 0x0f;
9895                       if (trace)
9896                         {
9897                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9898                                  "/** 1111 1101 0110 0000 rsrc rdst     shlr    %2, %0 */",
9899                                  op[0], op[1], op[2]);
9900                           printf ("  rsrc = 0x%x,", rsrc);
9901                           printf ("  rdst = 0x%x\n", rdst);
9902                         }
9903                       SYNTAX("shlr      %2, %0");
9904 #line 663 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9905                       ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F("-SZC");
9906
9907                     }
9908                   break;
9909               }
9910             break;
9911           case 0x61:
9912               GETBYTE ();
9913               switch (op[2] & 0x00)
9914               {
9915                 case 0x00:
9916                     {
9917                       /** 1111 1101 0110 0001 rsrc rdst shar    %2, %0 */
9918 #line 652 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9919                       int rsrc AU = (op[2] >> 4) & 0x0f;
9920 #line 652 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9921                       int rdst AU = op[2] & 0x0f;
9922                       if (trace)
9923                         {
9924                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9925                                  "/** 1111 1101 0110 0001 rsrc rdst     shar    %2, %0 */",
9926                                  op[0], op[1], op[2]);
9927                           printf ("  rsrc = 0x%x,", rsrc);
9928                           printf ("  rdst = 0x%x\n", rdst);
9929                         }
9930                       SYNTAX("shar      %2, %0");
9931 #line 653 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9932                       ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F("0SZC");
9933
9934                     }
9935                   break;
9936               }
9937             break;
9938           case 0x62:
9939               GETBYTE ();
9940               switch (op[2] & 0x00)
9941               {
9942                 case 0x00:
9943                     {
9944                       /** 1111 1101 0110 0010 rsrc rdst shll    %2, %0 */
9945 #line 642 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9946                       int rsrc AU = (op[2] >> 4) & 0x0f;
9947 #line 642 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9948                       int rdst AU = op[2] & 0x0f;
9949                       if (trace)
9950                         {
9951                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9952                                  "/** 1111 1101 0110 0010 rsrc rdst     shll    %2, %0 */",
9953                                  op[0], op[1], op[2]);
9954                           printf ("  rsrc = 0x%x,", rsrc);
9955                           printf ("  rdst = 0x%x\n", rdst);
9956                         }
9957                       SYNTAX("shll      %2, %0");
9958 #line 643 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9959                       ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F("OSZC");
9960
9961                     }
9962                   break;
9963               }
9964             break;
9965           case 0x64:
9966               GETBYTE ();
9967               switch (op[2] & 0x00)
9968               {
9969                 case 0x00:
9970                     {
9971                       /** 1111 1101 0110 0100 rsrc rdst rotr    %1, %0 */
9972 #line 686 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9973                       int rsrc AU = (op[2] >> 4) & 0x0f;
9974 #line 686 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9975                       int rdst AU = op[2] & 0x0f;
9976                       if (trace)
9977                         {
9978                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9979                                  "/** 1111 1101 0110 0100 rsrc rdst     rotr    %1, %0 */",
9980                                  op[0], op[1], op[2]);
9981                           printf ("  rsrc = 0x%x,", rsrc);
9982                           printf ("  rdst = 0x%x\n", rdst);
9983                         }
9984                       SYNTAX("rotr      %1, %0");
9985 #line 687 "/work/sources/gcc/current/opcodes/rx-decode.opc"
9986                       ID(rotr); SR(rsrc); DR(rdst); F("-SZC");
9987
9988                     }
9989                   break;
9990               }
9991             break;
9992           case 0x65:
9993               GETBYTE ();
9994               switch (op[2] & 0x00)
9995               {
9996                 case 0x00:
9997                     {
9998                       /** 1111 1101 0110 0101 rsrc rdst revw    %1, %0 */
9999 #line 689 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10000                       int rsrc AU = (op[2] >> 4) & 0x0f;
10001 #line 689 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10002                       int rdst AU = op[2] & 0x0f;
10003                       if (trace)
10004                         {
10005                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10006                                  "/** 1111 1101 0110 0101 rsrc rdst     revw    %1, %0 */",
10007                                  op[0], op[1], op[2]);
10008                           printf ("  rsrc = 0x%x,", rsrc);
10009                           printf ("  rdst = 0x%x\n", rdst);
10010                         }
10011                       SYNTAX("revw      %1, %0");
10012 #line 690 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10013                       ID(revw); SR(rsrc); DR(rdst);
10014
10015                     }
10016                   break;
10017               }
10018             break;
10019           case 0x66:
10020               GETBYTE ();
10021               switch (op[2] & 0x00)
10022               {
10023                 case 0x00:
10024                     {
10025                       /** 1111 1101 0110 0110 rsrc rdst rotl    %1, %0 */
10026 #line 680 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10027                       int rsrc AU = (op[2] >> 4) & 0x0f;
10028 #line 680 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10029                       int rdst AU = op[2] & 0x0f;
10030                       if (trace)
10031                         {
10032                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10033                                  "/** 1111 1101 0110 0110 rsrc rdst     rotl    %1, %0 */",
10034                                  op[0], op[1], op[2]);
10035                           printf ("  rsrc = 0x%x,", rsrc);
10036                           printf ("  rdst = 0x%x\n", rdst);
10037                         }
10038                       SYNTAX("rotl      %1, %0");
10039 #line 681 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10040                       ID(rotl); SR(rsrc); DR(rdst); F("-SZC");
10041
10042                     }
10043                   break;
10044               }
10045             break;
10046           case 0x67:
10047               GETBYTE ();
10048               switch (op[2] & 0x00)
10049               {
10050                 case 0x00:
10051                     {
10052                       /** 1111 1101 0110 0111 rsrc rdst revl    %1, %0 */
10053 #line 692 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10054                       int rsrc AU = (op[2] >> 4) & 0x0f;
10055 #line 692 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10056                       int rdst AU = op[2] & 0x0f;
10057                       if (trace)
10058                         {
10059                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10060                                  "/** 1111 1101 0110 0111 rsrc rdst     revl    %1, %0 */",
10061                                  op[0], op[1], op[2]);
10062                           printf ("  rsrc = 0x%x,", rsrc);
10063                           printf ("  rdst = 0x%x\n", rdst);
10064                         }
10065                       SYNTAX("revl      %1, %0");
10066 #line 693 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10067                       ID(revl); SR(rsrc); DR(rdst);
10068
10069                     /*----------------------------------------------------------------------*/
10070                     /* BRANCH                                                           */
10071
10072                     }
10073                   break;
10074               }
10075             break;
10076           case 0x68:
10077               GETBYTE ();
10078               switch (op[2] & 0x00)
10079               {
10080                 case 0x00:
10081                   op_semantics_74:
10082                     {
10083                       /** 1111 1101 0110 100c rsrc rdst mvtc    %1, %0 */
10084 #line 932 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10085                       int c AU = op[1] & 0x01;
10086 #line 932 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10087                       int rsrc AU = (op[2] >> 4) & 0x0f;
10088 #line 932 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10089                       int rdst AU = op[2] & 0x0f;
10090                       if (trace)
10091                         {
10092                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10093                                  "/** 1111 1101 0110 100c rsrc rdst     mvtc    %1, %0 */",
10094                                  op[0], op[1], op[2]);
10095                           printf ("  c = 0x%x,", c);
10096                           printf ("  rsrc = 0x%x,", rsrc);
10097                           printf ("  rdst = 0x%x\n", rdst);
10098                         }
10099                       SYNTAX("mvtc      %1, %0");
10100 #line 933 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10101                       ID(mov); SR(rsrc); DR(c*16+rdst + 16);
10102
10103                     }
10104                   break;
10105               }
10106             break;
10107           case 0x69:
10108               GETBYTE ();
10109               switch (op[2] & 0x00)
10110               {
10111                 case 0x00:
10112                   goto op_semantics_74;
10113                   break;
10114               }
10115             break;
10116           case 0x6a:
10117               GETBYTE ();
10118               switch (op[2] & 0x00)
10119               {
10120                 case 0x00:
10121                   op_semantics_75:
10122                     {
10123                       /** 1111 1101 0110 101s rsrc rdst mvfc    %1, %0 */
10124 #line 935 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10125                       int s AU = op[1] & 0x01;
10126 #line 935 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10127                       int rsrc AU = (op[2] >> 4) & 0x0f;
10128 #line 935 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10129                       int rdst AU = op[2] & 0x0f;
10130                       if (trace)
10131                         {
10132                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10133                                  "/** 1111 1101 0110 101s rsrc rdst     mvfc    %1, %0 */",
10134                                  op[0], op[1], op[2]);
10135                           printf ("  s = 0x%x,", s);
10136                           printf ("  rsrc = 0x%x,", rsrc);
10137                           printf ("  rdst = 0x%x\n", rdst);
10138                         }
10139                       SYNTAX("mvfc      %1, %0");
10140 #line 936 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10141                       ID(mov); SR((s*16+rsrc) + 16); DR(rdst);
10142
10143                     }
10144                   break;
10145               }
10146             break;
10147           case 0x6b:
10148               GETBYTE ();
10149               switch (op[2] & 0x00)
10150               {
10151                 case 0x00:
10152                   goto op_semantics_75;
10153                   break;
10154               }
10155             break;
10156           case 0x6c:
10157               GETBYTE ();
10158               switch (op[2] & 0x00)
10159               {
10160                 case 0x00:
10161                   op_semantics_76:
10162                     {
10163                       /** 1111 1101 0110 110i mmmm rdst rotr    #%1, %0 */
10164 #line 683 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10165                       int i AU = op[1] & 0x01;
10166 #line 683 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10167                       int mmmm AU = (op[2] >> 4) & 0x0f;
10168 #line 683 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10169                       int rdst AU = op[2] & 0x0f;
10170                       if (trace)
10171                         {
10172                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10173                                  "/** 1111 1101 0110 110i mmmm rdst     rotr    #%1, %0 */",
10174                                  op[0], op[1], op[2]);
10175                           printf ("  i = 0x%x,", i);
10176                           printf ("  mmmm = 0x%x,", mmmm);
10177                           printf ("  rdst = 0x%x\n", rdst);
10178                         }
10179                       SYNTAX("rotr      #%1, %0");
10180 #line 684 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10181                       ID(rotr); SC(i*16+mmmm); DR(rdst); F("-SZC");
10182
10183                     }
10184                   break;
10185               }
10186             break;
10187           case 0x6d:
10188               GETBYTE ();
10189               switch (op[2] & 0x00)
10190               {
10191                 case 0x00:
10192                   goto op_semantics_76;
10193                   break;
10194               }
10195             break;
10196           case 0x6e:
10197               GETBYTE ();
10198               switch (op[2] & 0x00)
10199               {
10200                 case 0x00:
10201                   op_semantics_77:
10202                     {
10203                       /** 1111 1101 0110 111i mmmm rdst rotl    #%1, %0 */
10204 #line 677 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10205                       int i AU = op[1] & 0x01;
10206 #line 677 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10207                       int mmmm AU = (op[2] >> 4) & 0x0f;
10208 #line 677 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10209                       int rdst AU = op[2] & 0x0f;
10210                       if (trace)
10211                         {
10212                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10213                                  "/** 1111 1101 0110 111i mmmm rdst     rotl    #%1, %0 */",
10214                                  op[0], op[1], op[2]);
10215                           printf ("  i = 0x%x,", i);
10216                           printf ("  mmmm = 0x%x,", mmmm);
10217                           printf ("  rdst = 0x%x\n", rdst);
10218                         }
10219                       SYNTAX("rotl      #%1, %0");
10220 #line 678 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10221                       ID(rotl); SC(i*16+mmmm); DR(rdst); F("-SZC");
10222
10223                     }
10224                   break;
10225               }
10226             break;
10227           case 0x6f:
10228               GETBYTE ();
10229               switch (op[2] & 0x00)
10230               {
10231                 case 0x00:
10232                   goto op_semantics_77;
10233                   break;
10234               }
10235             break;
10236           case 0x70:
10237               GETBYTE ();
10238               switch (op[2] & 0xf0)
10239               {
10240                 case 0x20:
10241                   op_semantics_78:
10242                     {
10243                       /** 1111 1101 0111 im00 0010rdst  adc     #%1, %0 */
10244 #line 467 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10245                       int im AU = (op[1] >> 2) & 0x03;
10246 #line 467 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10247                       int rdst AU = op[2] & 0x0f;
10248                       if (trace)
10249                         {
10250                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10251                                  "/** 1111 1101 0111 im00 0010rdst      adc     #%1, %0 */",
10252                                  op[0], op[1], op[2]);
10253                           printf ("  im = 0x%x,", im);
10254                           printf ("  rdst = 0x%x\n", rdst);
10255                         }
10256                       SYNTAX("adc       #%1, %0");
10257 #line 468 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10258                       ID(adc); SC(IMMex(im)); DR(rdst); F("OSZC");
10259
10260                     }
10261                   break;
10262                 case 0x40:
10263                   op_semantics_79:
10264                     {
10265                       /** 1111 1101 0111 im00 0100rdst  max     #%1, %0 */
10266 #line 549 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10267                       int im AU = (op[1] >> 2) & 0x03;
10268 #line 549 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10269                       int rdst AU = op[2] & 0x0f;
10270                       if (trace)
10271                         {
10272                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10273                                  "/** 1111 1101 0111 im00 0100rdst      max     #%1, %0 */",
10274                                  op[0], op[1], op[2]);
10275                           printf ("  im = 0x%x,", im);
10276                           printf ("  rdst = 0x%x\n", rdst);
10277                         }
10278                       SYNTAX("max       #%1, %0");
10279 #line 550 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10280                       ID(max); DR(rdst); SC(IMMex(im));
10281
10282                     }
10283                   break;
10284                 case 0x50:
10285                   op_semantics_80:
10286                     {
10287                       /** 1111 1101 0111 im00 0101rdst  min     #%1, %0 */
10288 #line 561 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10289                       int im AU = (op[1] >> 2) & 0x03;
10290 #line 561 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10291                       int rdst AU = op[2] & 0x0f;
10292                       if (trace)
10293                         {
10294                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10295                                  "/** 1111 1101 0111 im00 0101rdst      min     #%1, %0 */",
10296                                  op[0], op[1], op[2]);
10297                           printf ("  im = 0x%x,", im);
10298                           printf ("  rdst = 0x%x\n", rdst);
10299                         }
10300                       SYNTAX("min       #%1, %0");
10301 #line 562 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10302                       ID(min); DR(rdst); SC(IMMex(im));
10303
10304                     }
10305                   break;
10306                 case 0x60:
10307                   op_semantics_81:
10308                     {
10309                       /** 1111 1101 0111 im00 0110rdst  emul    #%1, %0 */
10310 #line 591 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10311                       int im AU = (op[1] >> 2) & 0x03;
10312 #line 591 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10313                       int rdst AU = op[2] & 0x0f;
10314                       if (trace)
10315                         {
10316                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10317                                  "/** 1111 1101 0111 im00 0110rdst      emul    #%1, %0 */",
10318                                  op[0], op[1], op[2]);
10319                           printf ("  im = 0x%x,", im);
10320                           printf ("  rdst = 0x%x\n", rdst);
10321                         }
10322                       SYNTAX("emul      #%1, %0");
10323 #line 592 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10324                       ID(emul); DR(rdst); SC(IMMex(im));
10325
10326                     }
10327                   break;
10328                 case 0x70:
10329                   op_semantics_82:
10330                     {
10331                       /** 1111 1101 0111 im00 0111rdst  emulu   #%1, %0 */
10332 #line 603 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10333                       int im AU = (op[1] >> 2) & 0x03;
10334 #line 603 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10335                       int rdst AU = op[2] & 0x0f;
10336                       if (trace)
10337                         {
10338                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10339                                  "/** 1111 1101 0111 im00 0111rdst      emulu   #%1, %0 */",
10340                                  op[0], op[1], op[2]);
10341                           printf ("  im = 0x%x,", im);
10342                           printf ("  rdst = 0x%x\n", rdst);
10343                         }
10344                       SYNTAX("emulu     #%1, %0");
10345 #line 604 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10346                       ID(emulu); DR(rdst); SC(IMMex(im));
10347
10348                     }
10349                   break;
10350                 case 0x80:
10351                   op_semantics_83:
10352                     {
10353                       /** 1111 1101 0111 im00 1000rdst  div     #%1, %0 */
10354 #line 615 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10355                       int im AU = (op[1] >> 2) & 0x03;
10356 #line 615 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10357                       int rdst AU = op[2] & 0x0f;
10358                       if (trace)
10359                         {
10360                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10361                                  "/** 1111 1101 0111 im00 1000rdst      div     #%1, %0 */",
10362                                  op[0], op[1], op[2]);
10363                           printf ("  im = 0x%x,", im);
10364                           printf ("  rdst = 0x%x\n", rdst);
10365                         }
10366                       SYNTAX("div       #%1, %0");
10367 #line 616 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10368                       ID(div); DR(rdst); SC(IMMex(im)); F("O---");
10369
10370                     }
10371                   break;
10372                 case 0x90:
10373                   op_semantics_84:
10374                     {
10375                       /** 1111 1101 0111 im00 1001rdst  divu    #%1, %0 */
10376 #line 627 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10377                       int im AU = (op[1] >> 2) & 0x03;
10378 #line 627 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10379                       int rdst AU = op[2] & 0x0f;
10380                       if (trace)
10381                         {
10382                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10383                                  "/** 1111 1101 0111 im00 1001rdst      divu    #%1, %0 */",
10384                                  op[0], op[1], op[2]);
10385                           printf ("  im = 0x%x,", im);
10386                           printf ("  rdst = 0x%x\n", rdst);
10387                         }
10388                       SYNTAX("divu      #%1, %0");
10389 #line 628 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10390                       ID(divu); DR(rdst); SC(IMMex(im)); F("O---");
10391
10392                     }
10393                   break;
10394                 case 0xc0:
10395                   op_semantics_85:
10396                     {
10397                       /** 1111 1101 0111 im00 1100rdst  tst     #%1, %2 */
10398 #line 446 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10399                       int im AU = (op[1] >> 2) & 0x03;
10400 #line 446 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10401                       int rdst AU = op[2] & 0x0f;
10402                       if (trace)
10403                         {
10404                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10405                                  "/** 1111 1101 0111 im00 1100rdst      tst     #%1, %2 */",
10406                                  op[0], op[1], op[2]);
10407                           printf ("  im = 0x%x,", im);
10408                           printf ("  rdst = 0x%x\n", rdst);
10409                         }
10410                       SYNTAX("tst       #%1, %2");
10411 #line 447 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10412                       ID(and); SC(IMMex(im)); S2R(rdst); F("-SZ-");
10413
10414                     }
10415                   break;
10416                 case 0xd0:
10417                   op_semantics_86:
10418                     {
10419                       /** 1111 1101 0111 im00 1101rdst  xor     #%1, %0 */
10420 #line 425 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10421                       int im AU = (op[1] >> 2) & 0x03;
10422 #line 425 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10423                       int rdst AU = op[2] & 0x0f;
10424                       if (trace)
10425                         {
10426                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10427                                  "/** 1111 1101 0111 im00 1101rdst      xor     #%1, %0 */",
10428                                  op[0], op[1], op[2]);
10429                           printf ("  im = 0x%x,", im);
10430                           printf ("  rdst = 0x%x\n", rdst);
10431                         }
10432                       SYNTAX("xor       #%1, %0");
10433 #line 426 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10434                       ID(xor); SC(IMMex(im)); DR(rdst); F("-SZ-");
10435
10436                     }
10437                   break;
10438                 case 0xe0:
10439                   op_semantics_87:
10440                     {
10441                       /** 1111 1101 0111 im00 1110rdst  stz     #%1, %0 */
10442 #line 371 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10443                       int im AU = (op[1] >> 2) & 0x03;
10444 #line 371 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10445                       int rdst AU = op[2] & 0x0f;
10446                       if (trace)
10447                         {
10448                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10449                                  "/** 1111 1101 0111 im00 1110rdst      stz     #%1, %0 */",
10450                                  op[0], op[1], op[2]);
10451                           printf ("  im = 0x%x,", im);
10452                           printf ("  rdst = 0x%x\n", rdst);
10453                         }
10454                       SYNTAX("stz       #%1, %0");
10455 #line 372 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10456                       ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z);
10457
10458                     }
10459                   break;
10460                 case 0xf0:
10461                   op_semantics_88:
10462                     {
10463                       /** 1111 1101 0111 im00 1111rdst  stnz    #%1, %0 */
10464 #line 374 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10465                       int im AU = (op[1] >> 2) & 0x03;
10466 #line 374 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10467                       int rdst AU = op[2] & 0x0f;
10468                       if (trace)
10469                         {
10470                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10471                                  "/** 1111 1101 0111 im00 1111rdst      stnz    #%1, %0 */",
10472                                  op[0], op[1], op[2]);
10473                           printf ("  im = 0x%x,", im);
10474                           printf ("  rdst = 0x%x\n", rdst);
10475                         }
10476                       SYNTAX("stnz      #%1, %0");
10477 #line 375 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10478                       ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz);
10479
10480                     /*----------------------------------------------------------------------*/
10481                     /* RTSD                                                                     */
10482
10483                     }
10484                   break;
10485                 default: UNSUPPORTED(); break;
10486               }
10487             break;
10488           case 0x72:
10489               GETBYTE ();
10490               switch (op[2] & 0xf0)
10491               {
10492                 case 0x00:
10493                     {
10494                       /** 1111 1101 0111 0010 0000 rdst fsub    #%1, %0 */
10495 #line 835 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10496                       int rdst AU = op[2] & 0x0f;
10497                       if (trace)
10498                         {
10499                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10500                                  "/** 1111 1101 0111 0010 0000 rdst     fsub    #%1, %0 */",
10501                                  op[0], op[1], op[2]);
10502                           printf ("  rdst = 0x%x\n", rdst);
10503                         }
10504                       SYNTAX("fsub      #%1, %0");
10505 #line 836 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10506                       ID(fsub); DR(rdst); SC(IMM(0)); F("-SZ-");
10507
10508                     }
10509                   break;
10510                 case 0x10:
10511                     {
10512                       /** 1111 1101 0111 0010 0001 rdst fcmp    #%1, %0 */
10513 #line 829 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10514                       int rdst AU = op[2] & 0x0f;
10515                       if (trace)
10516                         {
10517                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10518                                  "/** 1111 1101 0111 0010 0001 rdst     fcmp    #%1, %0 */",
10519                                  op[0], op[1], op[2]);
10520                           printf ("  rdst = 0x%x\n", rdst);
10521                         }
10522                       SYNTAX("fcmp      #%1, %0");
10523 #line 830 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10524                       ID(fcmp); DR(rdst); SC(IMM(0)); F("OSZ-");
10525
10526                     }
10527                   break;
10528                 case 0x20:
10529                     {
10530                       /** 1111 1101 0111 0010 0010 rdst fadd    #%1, %0 */
10531 #line 823 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10532                       int rdst AU = op[2] & 0x0f;
10533                       if (trace)
10534                         {
10535                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10536                                  "/** 1111 1101 0111 0010 0010 rdst     fadd    #%1, %0 */",
10537                                  op[0], op[1], op[2]);
10538                           printf ("  rdst = 0x%x\n", rdst);
10539                         }
10540                       SYNTAX("fadd      #%1, %0");
10541 #line 824 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10542                       ID(fadd); DR(rdst); SC(IMM(0)); F("-SZ-");
10543
10544                     }
10545                   break;
10546                 case 0x30:
10547                     {
10548                       /** 1111 1101 0111 0010 0011 rdst fmul    #%1, %0 */
10549 #line 844 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10550                       int rdst AU = op[2] & 0x0f;
10551                       if (trace)
10552                         {
10553                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10554                                  "/** 1111 1101 0111 0010 0011 rdst     fmul    #%1, %0 */",
10555                                  op[0], op[1], op[2]);
10556                           printf ("  rdst = 0x%x\n", rdst);
10557                         }
10558                       SYNTAX("fmul      #%1, %0");
10559 #line 845 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10560                       ID(fmul); DR(rdst); SC(IMM(0)); F("-SZ-");
10561
10562                     }
10563                   break;
10564                 case 0x40:
10565                     {
10566                       /** 1111 1101 0111 0010 0100 rdst fdiv    #%1, %0 */
10567 #line 850 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10568                       int rdst AU = op[2] & 0x0f;
10569                       if (trace)
10570                         {
10571                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10572                                  "/** 1111 1101 0111 0010 0100 rdst     fdiv    #%1, %0 */",
10573                                  op[0], op[1], op[2]);
10574                           printf ("  rdst = 0x%x\n", rdst);
10575                         }
10576                       SYNTAX("fdiv      #%1, %0");
10577 #line 851 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10578                       ID(fdiv); DR(rdst); SC(IMM(0)); F("-SZ-");
10579
10580                     }
10581                   break;
10582                 default: UNSUPPORTED(); break;
10583               }
10584             break;
10585           case 0x73:
10586               GETBYTE ();
10587               switch (op[2] & 0xe0)
10588               {
10589                 case 0x00:
10590                   op_semantics_89:
10591                     {
10592                       /** 1111 1101 0111 im11 000crdst  mvtc    #%1, %0 */
10593 #line 929 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10594                       int im AU = (op[1] >> 2) & 0x03;
10595 #line 929 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10596                       int crdst AU = op[2] & 0x1f;
10597                       if (trace)
10598                         {
10599                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10600                                  "/** 1111 1101 0111 im11 000crdst      mvtc    #%1, %0 */",
10601                                  op[0], op[1], op[2]);
10602                           printf ("  im = 0x%x,", im);
10603                           printf ("  crdst = 0x%x\n", crdst);
10604                         }
10605                       SYNTAX("mvtc      #%1, %0");
10606 #line 930 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10607                       ID(mov); SC(IMMex(im)); DR(crdst + 16);
10608
10609                     }
10610                   break;
10611                 default: UNSUPPORTED(); break;
10612               }
10613             break;
10614           case 0x74:
10615               GETBYTE ();
10616               switch (op[2] & 0xf0)
10617               {
10618                 case 0x20:
10619                   goto op_semantics_78;
10620                   break;
10621                 case 0x40:
10622                   goto op_semantics_79;
10623                   break;
10624                 case 0x50:
10625                   goto op_semantics_80;
10626                   break;
10627                 case 0x60:
10628                   goto op_semantics_81;
10629                   break;
10630                 case 0x70:
10631                   goto op_semantics_82;
10632                   break;
10633                 case 0x80:
10634                   goto op_semantics_83;
10635                   break;
10636                 case 0x90:
10637                   goto op_semantics_84;
10638                   break;
10639                 case 0xc0:
10640                   goto op_semantics_85;
10641                   break;
10642                 case 0xd0:
10643                   goto op_semantics_86;
10644                   break;
10645                 case 0xe0:
10646                   goto op_semantics_87;
10647                   break;
10648                 case 0xf0:
10649                   goto op_semantics_88;
10650                   break;
10651                 default: UNSUPPORTED(); break;
10652               }
10653             break;
10654           case 0x77:
10655               GETBYTE ();
10656               switch (op[2] & 0xe0)
10657               {
10658                 case 0x00:
10659                   goto op_semantics_89;
10660                   break;
10661                 default: UNSUPPORTED(); break;
10662               }
10663             break;
10664           case 0x78:
10665               GETBYTE ();
10666               switch (op[2] & 0xf0)
10667               {
10668                 case 0x20:
10669                   goto op_semantics_78;
10670                   break;
10671                 case 0x40:
10672                   goto op_semantics_79;
10673                   break;
10674                 case 0x50:
10675                   goto op_semantics_80;
10676                   break;
10677                 case 0x60:
10678                   goto op_semantics_81;
10679                   break;
10680                 case 0x70:
10681                   goto op_semantics_82;
10682                   break;
10683                 case 0x80:
10684                   goto op_semantics_83;
10685                   break;
10686                 case 0x90:
10687                   goto op_semantics_84;
10688                   break;
10689                 case 0xc0:
10690                   goto op_semantics_85;
10691                   break;
10692                 case 0xd0:
10693                   goto op_semantics_86;
10694                   break;
10695                 case 0xe0:
10696                   goto op_semantics_87;
10697                   break;
10698                 case 0xf0:
10699                   goto op_semantics_88;
10700                   break;
10701                 default: UNSUPPORTED(); break;
10702               }
10703             break;
10704           case 0x7b:
10705               GETBYTE ();
10706               switch (op[2] & 0xe0)
10707               {
10708                 case 0x00:
10709                   goto op_semantics_89;
10710                   break;
10711                 default: UNSUPPORTED(); break;
10712               }
10713             break;
10714           case 0x7c:
10715               GETBYTE ();
10716               switch (op[2] & 0xf0)
10717               {
10718                 case 0x20:
10719                   goto op_semantics_78;
10720                   break;
10721                 case 0x40:
10722                   goto op_semantics_79;
10723                   break;
10724                 case 0x50:
10725                   goto op_semantics_80;
10726                   break;
10727                 case 0x60:
10728                   goto op_semantics_81;
10729                   break;
10730                 case 0x70:
10731                   goto op_semantics_82;
10732                   break;
10733                 case 0x80:
10734                   goto op_semantics_83;
10735                   break;
10736                 case 0x90:
10737                   goto op_semantics_84;
10738                   break;
10739                 case 0xc0:
10740                   goto op_semantics_85;
10741                   break;
10742                 case 0xd0:
10743                   goto op_semantics_86;
10744                   break;
10745                 case 0xe0:
10746                   goto op_semantics_87;
10747                   break;
10748                 case 0xf0:
10749                   goto op_semantics_88;
10750                   break;
10751                 default: UNSUPPORTED(); break;
10752               }
10753             break;
10754           case 0x7f:
10755               GETBYTE ();
10756               switch (op[2] & 0xe0)
10757               {
10758                 case 0x00:
10759                   goto op_semantics_89;
10760                   break;
10761                 default: UNSUPPORTED(); break;
10762               }
10763             break;
10764           case 0x80:
10765               GETBYTE ();
10766               switch (op[2] & 0x00)
10767               {
10768                 case 0x00:
10769                   op_semantics_90:
10770                     {
10771                       /** 1111 1101 100immmm rsrc rdst  shlr    #%2, %1, %0 */
10772 #line 665 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10773                       int immmm AU = op[1] & 0x1f;
10774 #line 665 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10775                       int rsrc AU = (op[2] >> 4) & 0x0f;
10776 #line 665 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10777                       int rdst AU = op[2] & 0x0f;
10778                       if (trace)
10779                         {
10780                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10781                                  "/** 1111 1101 100immmm rsrc rdst      shlr    #%2, %1, %0 */",
10782                                  op[0], op[1], op[2]);
10783                           printf ("  immmm = 0x%x,", immmm);
10784                           printf ("  rsrc = 0x%x,", rsrc);
10785                           printf ("  rdst = 0x%x\n", rdst);
10786                         }
10787                       SYNTAX("shlr      #%2, %1, %0");
10788 #line 666 "/work/sources/gcc/current/opcodes/rx-decode.opc"
10789                       ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F("-SZC");
10790
10791                     /*----------------------------------------------------------------------*/
10792                     /* ROTATE                                                           */
10793
10794                     }
10795                   break;
10796               }
10797             break;
10798           case 0x81:
10799               GETBYTE ();
10800               switch (op[2] & 0x00)
10801               {
10802                 case 0x00:
10803                   goto op_semantics_90;
10804                   break;
10805               }
10806             break;
10807           case 0x82:
10808               GETBYTE ();
10809               switch (op[2] & 0x00)
10810               {
10811                 case 0x00:
10812                   goto op_semantics_90;
10813                   break;
10814               }
10815             break;
10816           case 0x83:
10817               GETBYTE ();
10818               switch (op[2] & 0x00)
10819               {
10820                 case 0x00:
10821                   goto op_semantics_90;
10822                   break;
10823               }
10824             break;
10825           case 0x84:
10826               GETBYTE ();
10827               switch (op[2] & 0x00)
10828               {
10829                 case 0x00:
10830                   goto op_semantics_90;
10831                   break;
10832               }
10833             break;
10834           case 0x85:
10835               GETBYTE ();
10836               switch (op[2] & 0x00)
10837               {
10838                 case 0x00:
10839                   goto op_semantics_90;
10840                   break;
10841               }
10842             break;
10843           case 0x86:
10844               GETBYTE ();
10845               switch (op[2] & 0x00)
10846               {
10847                 case 0x00:
10848                   goto op_semantics_90;
10849                   break;
10850               }
10851             break;
10852           case 0x87:
10853               GETBYTE ();
10854               switch (op[2] & 0x00)
10855               {
10856                 case 0x00:
10857                   goto op_semantics_90;
10858                   break;
10859               }
10860             break;
10861           case 0x88:
10862               GETBYTE ();
10863               switch (op[2] & 0x00)
10864               {
10865                 case 0x00:
10866                   goto op_semantics_90;
10867                   break;
10868               }
10869             break;
10870           case 0x89:
10871               GETBYTE ();
10872               switch (op[2] & 0x00)
10873               {
10874                 case 0x00:
10875                   goto op_semantics_90;
10876                   break;
10877               }
10878             break;
10879           case 0x8a:
10880               GETBYTE ();
10881               switch (op[2] & 0x00)
10882               {
10883                 case 0x00:
10884                   goto op_semantics_90;
10885                   break;
10886               }
10887             break;
10888           case 0x8b:
10889               GETBYTE ();
10890               switch (op[2] & 0x00)
10891               {
10892                 case 0x00:
10893                   goto op_semantics_90;
10894                   break;
10895               }
10896             break;
10897           case 0x8c:
10898               GETBYTE ();
10899               switch (op[2] & 0x00)
10900               {
10901                 case 0x00:
10902                   goto op_semantics_90;
10903                   break;
10904               }
10905             break;
10906           case 0x8d:
10907               GETBYTE ();
10908               switch (op[2] & 0x00)
10909               {
10910                 case 0x00:
10911                   goto op_semantics_90;
10912                   break;
10913               }
10914             break;
10915           case 0x8e:
10916               GETBYTE ();
10917               switch (op[2] & 0x00)
10918               {
10919                 case 0x00:
10920                   goto op_semantics_90;
10921                   break;
10922               }
10923             break;
10924           case 0x8f:
10925               GETBYTE ();
10926               switch (op[2] & 0x00)
10927               {
10928                 case 0x00:
10929                   goto op_semantics_90;
10930                   break;
10931               }
10932             break;
10933           case 0x90:
10934               GETBYTE ();
10935               switch (op[2] & 0x00)
10936               {
10937                 case 0x00:
10938                   goto op_semantics_90;
10939                   break;
10940               }
10941             break;
10942           case 0x91:
10943               GETBYTE ();
10944               switch (op[2] & 0x00)
10945               {
10946                 case 0x00:
10947                   goto op_semantics_90;
10948                   break;
10949               }
10950             break;
10951           case 0x92:
10952               GETBYTE ();
10953               switch (op[2] & 0x00)
10954               {
10955                 case 0x00:
10956                   goto op_semantics_90;
10957                   break;
10958               }
10959             break;
10960           case 0x93:
10961               GETBYTE ();
10962               switch (op[2] & 0x00)
10963               {
10964                 case 0x00:
10965                   goto op_semantics_90;
10966                   break;
10967               }
10968             break;
10969           case 0x94:
10970               GETBYTE ();
10971               switch (op[2] & 0x00)
10972               {
10973                 case 0x00:
10974                   goto op_semantics_90;
10975                   break;
10976               }
10977             break;
10978           case 0x95:
10979               GETBYTE ();
10980               switch (op[2] & 0x00)
10981               {
10982                 case 0x00:
10983                   goto op_semantics_90;
10984                   break;
10985               }
10986             break;
10987           case 0x96:
10988               GETBYTE ();
10989               switch (op[2] & 0x00)
10990               {
10991                 case 0x00:
10992                   goto op_semantics_90;
10993                   break;
10994               }
10995             break;
10996           case 0x97:
10997               GETBYTE ();
10998               switch (op[2] & 0x00)
10999               {
11000                 case 0x00:
11001                   goto op_semantics_90;
11002                   break;
11003               }
11004             break;
11005           case 0x98:
11006               GETBYTE ();
11007               switch (op[2] & 0x00)
11008               {
11009                 case 0x00:
11010                   goto op_semantics_90;
11011                   break;
11012               }
11013             break;
11014           case 0x99:
11015               GETBYTE ();
11016               switch (op[2] & 0x00)
11017               {
11018                 case 0x00:
11019                   goto op_semantics_90;
11020                   break;
11021               }
11022             break;
11023           case 0x9a:
11024               GETBYTE ();
11025               switch (op[2] & 0x00)
11026               {
11027                 case 0x00:
11028                   goto op_semantics_90;
11029                   break;
11030               }
11031             break;
11032           case 0x9b:
11033               GETBYTE ();
11034               switch (op[2] & 0x00)
11035               {
11036                 case 0x00:
11037                   goto op_semantics_90;
11038                   break;
11039               }
11040             break;
11041           case 0x9c:
11042               GETBYTE ();
11043               switch (op[2] & 0x00)
11044               {
11045                 case 0x00:
11046                   goto op_semantics_90;
11047                   break;
11048               }
11049             break;
11050           case 0x9d:
11051               GETBYTE ();
11052               switch (op[2] & 0x00)
11053               {
11054                 case 0x00:
11055                   goto op_semantics_90;
11056                   break;
11057               }
11058             break;
11059           case 0x9e:
11060               GETBYTE ();
11061               switch (op[2] & 0x00)
11062               {
11063                 case 0x00:
11064                   goto op_semantics_90;
11065                   break;
11066               }
11067             break;
11068           case 0x9f:
11069               GETBYTE ();
11070               switch (op[2] & 0x00)
11071               {
11072                 case 0x00:
11073                   goto op_semantics_90;
11074                   break;
11075               }
11076             break;
11077           case 0xa0:
11078               GETBYTE ();
11079               switch (op[2] & 0x00)
11080               {
11081                 case 0x00:
11082                   op_semantics_91:
11083                     {
11084                       /** 1111 1101 101immmm rsrc rdst  shar    #%2, %1, %0 */
11085 #line 655 "/work/sources/gcc/current/opcodes/rx-decode.opc"
11086                       int immmm AU = op[1] & 0x1f;
11087 #line 655 "/work/sources/gcc/current/opcodes/rx-decode.opc"
11088                       int rsrc AU = (op[2] >> 4) & 0x0f;
11089 #line 655 "/work/sources/gcc/current/opcodes/rx-decode.opc"
11090                       int rdst AU = op[2] & 0x0f;
11091                       if (trace)
11092                         {
11093                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11094                                  "/** 1111 1101 101immmm rsrc rdst      shar    #%2, %1, %0 */",
11095                                  op[0], op[1], op[2]);
11096                           printf ("  immmm = 0x%x,", immmm);
11097                           printf ("  rsrc = 0x%x,", rsrc);
11098                           printf ("  rdst = 0x%x\n", rdst);
11099                         }
11100                       SYNTAX("shar      #%2, %1, %0");
11101 #line 656 "/work/sources/gcc/current/opcodes/rx-decode.opc"
11102                       ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F("0SZC");
11103
11104
11105                     }
11106                   break;
11107               }
11108             break;
11109           case 0xa1:
11110               GETBYTE ();
11111               switch (op[2] & 0x00)
11112               {
11113                 case 0x00:
11114                   goto op_semantics_91;
11115                   break;
11116               }
11117             break;
11118           case 0xa2:
11119               GETBYTE ();
11120               switch (op[2] & 0x00)
11121               {
11122                 case 0x00:
11123                   goto op_semantics_91;
11124                   break;
11125               }
11126             break;
11127           case 0xa3:
11128               GETBYTE ();
11129               switch (op[2] & 0x00)
11130               {
11131                 case 0x00:
11132                   goto op_semantics_91;
11133                   break;
11134               }
11135             break;
11136           case 0xa4:
11137               GETBYTE ();
11138               switch (op[2] & 0x00)
11139               {
11140                 case 0x00:
11141                   goto op_semantics_91;
11142                   break;
11143               }
11144             break;
11145           case 0xa5:
11146               GETBYTE ();
11147               switch (op[2] & 0x00)
11148               {
11149                 case 0x00:
11150                   goto op_semantics_91;
11151                   break;
11152               }
11153             break;
11154           case 0xa6:
11155               GETBYTE ();
11156               switch (op[2] & 0x00)
11157               {
11158                 case 0x00:
11159                   goto op_semantics_91;
11160                   break;
11161               }
11162             break;
11163           case 0xa7:
11164               GETBYTE ();
11165               switch (op[2] & 0x00)
11166               {
11167                 case 0x00:
11168                   goto op_semantics_91;
11169                   break;
11170               }
11171             break;
11172           case 0xa8:
11173               GETBYTE ();
11174               switch (op[2] & 0x00)
11175               {
11176                 case 0x00:
11177                   goto op_semantics_91;
11178                   break;
11179               }
11180             break;
11181           case 0xa9:
11182               GETBYTE ();
11183               switch (op[2] & 0x00)
11184               {
11185                 case 0x00:
11186                   goto op_semantics_91;
11187                   break;
11188               }
11189             break;
11190           case 0xaa:
11191               GETBYTE ();
11192               switch (op[2] & 0x00)
11193               {
11194                 case 0x00:
11195                   goto op_semantics_91;
11196                   break;
11197               }
11198             break;
11199           case 0xab:
11200               GETBYTE ();
11201               switch (op[2] & 0x00)
11202               {
11203                 case 0x00:
11204                   goto op_semantics_91;
11205                   break;
11206               }
11207             break;
11208           case 0xac:
11209               GETBYTE ();
11210               switch (op[2] & 0x00)
11211               {
11212                 case 0x00:
11213                   goto op_semantics_91;
11214                   break;
11215               }
11216             break;
11217           case 0xad:
11218               GETBYTE ();
11219               switch (op[2] & 0x00)
11220               {
11221                 case 0x00:
11222                   goto op_semantics_91;
11223                   break;
11224               }
11225             break;
11226           case 0xae:
11227               GETBYTE ();
11228               switch (op[2] & 0x00)
11229               {
11230                 case 0x00:
11231                   goto op_semantics_91;
11232                   break;
11233               }
11234             break;
11235           case 0xaf:
11236               GETBYTE ();
11237               switch (op[2] & 0x00)
11238               {
11239                 case 0x00:
11240                   goto op_semantics_91;
11241                   break;
11242               }
11243             break;
11244           case 0xb0:
11245               GETBYTE ();
11246               switch (op[2] & 0x00)
11247               {
11248                 case 0x00:
11249                   goto op_semantics_91;
11250                   break;
11251               }
11252             break;
11253           case 0xb1:
11254               GETBYTE ();
11255               switch (op[2] & 0x00)
11256               {
11257                 case 0x00:
11258                   goto op_semantics_91;
11259                   break;
11260               }
11261             break;
11262           case 0xb2:
11263               GETBYTE ();
11264               switch (op[2] & 0x00)
11265               {
11266                 case 0x00:
11267                   goto op_semantics_91;
11268                   break;
11269               }
11270             break;
11271           case 0xb3:
11272               GETBYTE ();
11273               switch (op[2] & 0x00)
11274               {
11275                 case 0x00:
11276                   goto op_semantics_91;
11277                   break;
11278               }
11279             break;
11280           case 0xb4:
11281               GETBYTE ();
11282               switch (op[2] & 0x00)
11283               {
11284                 case 0x00:
11285                   goto op_semantics_91;
11286                   break;
11287               }
11288             break;
11289           case 0xb5:
11290               GETBYTE ();
11291               switch (op[2] & 0x00)
11292               {
11293                 case 0x00:
11294                   goto op_semantics_91;
11295                   break;
11296               }
11297             break;
11298           case 0xb6:
11299               GETBYTE ();
11300               switch (op[2] & 0x00)
11301               {
11302                 case 0x00:
11303                   goto op_semantics_91;
11304                   break;
11305               }
11306             break;
11307           case 0xb7:
11308               GETBYTE ();
11309               switch (op[2] & 0x00)
11310               {
11311                 case 0x00:
11312                   goto op_semantics_91;
11313                   break;
11314               }
11315             break;
11316           case 0xb8:
11317               GETBYTE ();
11318               switch (op[2] & 0x00)
11319               {
11320                 case 0x00:
11321                   goto op_semantics_91;
11322                   break;
11323               }
11324             break;
11325           case 0xb9:
11326               GETBYTE ();
11327               switch (op[2] & 0x00)
11328               {
11329                 case 0x00:
11330                   goto op_semantics_91;
11331                   break;
11332               }
11333             break;
11334           case 0xba:
11335               GETBYTE ();
11336               switch (op[2] & 0x00)
11337               {
11338                 case 0x00:
11339                   goto op_semantics_91;
11340                   break;
11341               }
11342             break;
11343           case 0xbb:
11344               GETBYTE ();
11345               switch (op[2] & 0x00)
11346               {
11347                 case 0x00:
11348                   goto op_semantics_91;
11349                   break;
11350               }
11351             break;
11352           case 0xbc:
11353               GETBYTE ();
11354               switch (op[2] & 0x00)
11355               {
11356                 case 0x00:
11357                   goto op_semantics_91;
11358                   break;
11359               }
11360             break;
11361           case 0xbd:
11362               GETBYTE ();
11363               switch (op[2] & 0x00)
11364               {
11365                 case 0x00:
11366                   goto op_semantics_91;
11367                   break;
11368               }
11369             break;
11370           case 0xbe:
11371               GETBYTE ();
11372               switch (op[2] & 0x00)
11373               {
11374                 case 0x00:
11375                   goto op_semantics_91;
11376                   break;
11377               }
11378             break;
11379           case 0xbf:
11380               GETBYTE ();
11381               switch (op[2] & 0x00)
11382               {
11383                 case 0x00:
11384                   goto op_semantics_91;
11385                   break;
11386               }
11387             break;
11388           case 0xc0:
11389               GETBYTE ();
11390               switch (op[2] & 0x00)
11391               {
11392                 case 0x00:
11393                   op_semantics_92:
11394                     {
11395                       /** 1111 1101 110immmm rsrc rdst  shll    #%2, %1, %0 */
11396 #line 645 "/work/sources/gcc/current/opcodes/rx-decode.opc"
11397                       int immmm AU = op[1] & 0x1f;
11398 #line 645 "/work/sources/gcc/current/opcodes/rx-decode.opc"
11399                       int rsrc AU = (op[2] >> 4) & 0x0f;
11400 #line 645 "/work/sources/gcc/current/opcodes/rx-decode.opc"
11401                       int rdst AU = op[2] & 0x0f;
11402                       if (trace)
11403                         {
11404                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11405                                  "/** 1111 1101 110immmm rsrc rdst      shll    #%2, %1, %0 */",
11406                                  op[0], op[1], op[2]);
11407                           printf ("  immmm = 0x%x,", immmm);
11408                           printf ("  rsrc = 0x%x,", rsrc);
11409                           printf ("  rdst = 0x%x\n", rdst);
11410                         }
11411                       SYNTAX("shll      #%2, %1, %0");
11412 #line 646 "/work/sources/gcc/current/opcodes/rx-decode.opc"
11413                       ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F("OSZC");
11414
11415
11416                     }
11417                   break;
11418               }
11419             break;
11420           case 0xc1:
11421               GETBYTE ();
11422               switch (op[2] & 0x00)
11423               {
11424                 case 0x00:
11425                   goto op_semantics_92;
11426                   break;
11427               }
11428             break;
11429           case 0xc2:
11430               GETBYTE ();
11431               switch (op[2] & 0x00)
11432               {
11433                 case 0x00:
11434                   goto op_semantics_92;
11435                   break;
11436               }
11437             break;
11438           case 0xc3:
11439               GETBYTE ();
11440               switch (op[2] & 0x00)
11441               {
11442                 case 0x00:
11443                   goto op_semantics_92;
11444                   break;
11445               }
11446             break;
11447           case 0xc4:
11448               GETBYTE ();
11449               switch (op[2] & 0x00)
11450               {
11451                 case 0x00:
11452                   goto op_semantics_92;
11453                   break;
11454               }
11455             break;
11456           case 0xc5:
11457               GETBYTE ();
11458               switch (op[2] & 0x00)
11459               {
11460                 case 0x00:
11461                   goto op_semantics_92;
11462                   break;
11463               }
11464             break;
11465           case 0xc6:
11466               GETBYTE ();
11467               switch (op[2] & 0x00)
11468               {
11469                 case 0x00:
11470                   goto op_semantics_92;
11471                   break;
11472               }
11473             break;
11474           case 0xc7:
11475               GETBYTE ();
11476               switch (op[2] & 0x00)
11477               {
11478                 case 0x00:
11479                   goto op_semantics_92;
11480                   break;
11481               }
11482             break;
11483           case 0xc8:
11484               GETBYTE ();
11485               switch (op[2] & 0x00)
11486               {
11487                 case 0x00:
11488                   goto op_semantics_92;
11489                   break;
11490               }
11491             break;
11492           case 0xc9:
11493               GETBYTE ();
11494               switch (op[2] & 0x00)
11495               {
11496                 case 0x00:
11497                   goto op_semantics_92;
11498                   break;
11499               }
11500             break;
11501           case 0xca:
11502               GETBYTE ();
11503               switch (op[2] & 0x00)
11504               {
11505                 case 0x00:
11506                   goto op_semantics_92;
11507                   break;
11508               }
11509             break;
11510           case 0xcb:
11511               GETBYTE ();
11512               switch (op[2] & 0x00)
11513               {
11514                 case 0x00:
11515                   goto op_semantics_92;
11516                   break;
11517               }
11518             break;
11519           case 0xcc:
11520               GETBYTE ();
11521               switch (op[2] & 0x00)
11522               {
11523                 case 0x00:
11524                   goto op_semantics_92;
11525                   break;
11526               }
11527             break;
11528           case 0xcd:
11529               GETBYTE ();
11530               switch (op[2] & 0x00)
11531               {
11532                 case 0x00:
11533                   goto op_semantics_92;
11534                   break;
11535               }
11536             break;
11537           case 0xce:
11538               GETBYTE ();
11539               switch (op[2] & 0x00)
11540               {
11541                 case 0x00:
11542                   goto op_semantics_92;
11543                   break;
11544               }
11545             break;
11546           case 0xcf:
11547               GETBYTE ();
11548               switch (op[2] & 0x00)
11549               {
11550                 case 0x00:
11551                   goto op_semantics_92;
11552                   break;
11553               }
11554             break;
11555           case 0xd0:
11556               GETBYTE ();
11557               switch (op[2] & 0x00)
11558               {
11559                 case 0x00:
11560                   goto op_semantics_92;
11561                   break;
11562               }
11563             break;
11564           case 0xd1:
11565               GETBYTE ();
11566               switch (op[2] & 0x00)
11567               {
11568                 case 0x00:
11569                   goto op_semantics_92;
11570                   break;
11571               }
11572             break;
11573           case 0xd2:
11574               GETBYTE ();
11575               switch (op[2] & 0x00)
11576               {
11577                 case 0x00:
11578                   goto op_semantics_92;
11579                   break;
11580               }
11581             break;
11582           case 0xd3:
11583               GETBYTE ();
11584               switch (op[2] & 0x00)
11585               {
11586                 case 0x00:
11587                   goto op_semantics_92;
11588                   break;
11589               }
11590             break;
11591           case 0xd4:
11592               GETBYTE ();
11593               switch (op[2] & 0x00)
11594               {
11595                 case 0x00:
11596                   goto op_semantics_92;
11597                   break;
11598               }
11599             break;
11600           case 0xd5:
11601               GETBYTE ();
11602               switch (op[2] & 0x00)
11603               {
11604                 case 0x00:
11605                   goto op_semantics_92;
11606                   break;
11607               }
11608             break;
11609           case 0xd6:
11610               GETBYTE ();
11611               switch (op[2] & 0x00)
11612               {
11613                 case 0x00:
11614                   goto op_semantics_92;
11615                   break;
11616               }
11617             break;
11618           case 0xd7:
11619               GETBYTE ();
11620               switch (op[2] & 0x00)
11621               {
11622                 case 0x00:
11623                   goto op_semantics_92;
11624                   break;
11625               }
11626             break;
11627           case 0xd8:
11628               GETBYTE ();
11629               switch (op[2] & 0x00)
11630               {
11631                 case 0x00:
11632                   goto op_semantics_92;
11633                   break;
11634               }
11635             break;
11636           case 0xd9:
11637               GETBYTE ();
11638               switch (op[2] & 0x00)
11639               {
11640                 case 0x00:
11641                   goto op_semantics_92;
11642                   break;
11643               }
11644             break;
11645           case 0xda:
11646               GETBYTE ();
11647               switch (op[2] & 0x00)
11648               {
11649                 case 0x00:
11650                   goto op_semantics_92;
11651                   break;
11652               }
11653             break;
11654           case 0xdb:
11655               GETBYTE ();
11656               switch (op[2] & 0x00)
11657               {
11658                 case 0x00:
11659                   goto op_semantics_92;
11660                   break;
11661               }
11662             break;
11663           case 0xdc:
11664               GETBYTE ();
11665               switch (op[2] & 0x00)
11666               {
11667                 case 0x00:
11668                   goto op_semantics_92;
11669                   break;
11670               }
11671             break;
11672           case 0xdd:
11673               GETBYTE ();
11674               switch (op[2] & 0x00)
11675               {
11676                 case 0x00:
11677                   goto op_semantics_92;
11678                   break;
11679               }
11680             break;
11681           case 0xde:
11682               GETBYTE ();
11683               switch (op[2] & 0x00)
11684               {
11685                 case 0x00:
11686                   goto op_semantics_92;
11687                   break;
11688               }
11689             break;
11690           case 0xdf:
11691               GETBYTE ();
11692               switch (op[2] & 0x00)
11693               {
11694                 case 0x00:
11695                   goto op_semantics_92;
11696                   break;
11697               }
11698             break;
11699           case 0xe0:
11700               GETBYTE ();
11701               switch (op[2] & 0xf0)
11702               {
11703                 case 0x00:
11704                 case 0x10:
11705                 case 0x20:
11706                 case 0x30:
11707                 case 0x40:
11708                 case 0x50:
11709                 case 0x60:
11710                 case 0x70:
11711                 case 0x80:
11712                 case 0x90:
11713                 case 0xa0:
11714                 case 0xb0:
11715                 case 0xc0:
11716                 case 0xd0:
11717                 case 0xe0:
11718                   op_semantics_93:
11719                     {
11720                       /** 1111 1101 111 bittt cond rdst bm%2    #%1, %0%S0 */
11721 #line 911 "/work/sources/gcc/current/opcodes/rx-decode.opc"
11722                       int bittt AU = op[1] & 0x1f;
11723 #line 911 "/work/sources/gcc/current/opcodes/rx-decode.opc"
11724                       int cond AU = (op[2] >> 4) & 0x0f;
11725 #line 911 "/work/sources/gcc/current/opcodes/rx-decode.opc"
11726                       int rdst AU = op[2] & 0x0f;
11727                       if (trace)
11728                         {
11729                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11730                                  "/** 1111 1101 111 bittt cond rdst     bm%2    #%1, %0%S0 */",
11731                                  op[0], op[1], op[2]);
11732                           printf ("  bittt = 0x%x,", bittt);
11733                           printf ("  cond = 0x%x,", cond);
11734                           printf ("  rdst = 0x%x\n", rdst);
11735                         }
11736                       SYNTAX("bm%2      #%1, %0%S0");
11737 #line 912 "/work/sources/gcc/current/opcodes/rx-decode.opc"
11738                       ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst);
11739
11740                     /*----------------------------------------------------------------------*/
11741                     /* CONTROL REGISTERS                                                        */
11742
11743                     }
11744                   break;
11745                 case 0xf0:
11746                   op_semantics_94:
11747                     {
11748                       /** 1111 1101 111bittt 1111 rdst  bnot    #%1, %0 */
11749 #line 904 "/work/sources/gcc/current/opcodes/rx-decode.opc"
11750                       int bittt AU = op[1] & 0x1f;
11751 #line 904 "/work/sources/gcc/current/opcodes/rx-decode.opc"
11752                       int rdst AU = op[2] & 0x0f;
11753                       if (trace)
11754                         {
11755                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11756                                  "/** 1111 1101 111bittt 1111 rdst      bnot    #%1, %0 */",
11757                                  op[0], op[1], op[2]);
11758                           printf ("  bittt = 0x%x,", bittt);
11759                           printf ("  rdst = 0x%x\n", rdst);
11760                         }
11761                       SYNTAX("bnot      #%1, %0");
11762 #line 905 "/work/sources/gcc/current/opcodes/rx-decode.opc"
11763                       ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst);
11764
11765
11766                     }
11767                   break;
11768               }
11769             break;
11770           case 0xe1:
11771               GETBYTE ();
11772               switch (op[2] & 0xf0)
11773               {
11774                 case 0x00:
11775                 case 0x10:
11776                 case 0x20:
11777                 case 0x30:
11778                 case 0x40:
11779                 case 0x50:
11780                 case 0x60:
11781                 case 0x70:
11782                 case 0x80:
11783                 case 0x90:
11784                 case 0xa0:
11785                 case 0xb0:
11786                 case 0xc0:
11787                 case 0xd0:
11788                 case 0xe0:
11789                   goto op_semantics_93;
11790                   break;
11791                 case 0xf0:
11792                   goto op_semantics_94;
11793                   break;
11794               }
11795             break;
11796           case 0xe2:
11797               GETBYTE ();
11798               switch (op[2] & 0xf0)
11799               {
11800                 case 0x00:
11801                 case 0x10:
11802                 case 0x20:
11803                 case 0x30:
11804                 case 0x40:
11805                 case 0x50:
11806                 case 0x60:
11807                 case 0x70:
11808                 case 0x80:
11809                 case 0x90:
11810                 case 0xa0:
11811                 case 0xb0:
11812                 case 0xc0:
11813                 case 0xd0:
11814                 case 0xe0:
11815                   goto op_semantics_93;
11816                   break;
11817                 case 0xf0:
11818                   goto op_semantics_94;
11819                   break;
11820               }
11821             break;
11822           case 0xe3:
11823               GETBYTE ();
11824               switch (op[2] & 0xf0)
11825               {
11826                 case 0x00:
11827                 case 0x10:
11828                 case 0x20:
11829                 case 0x30:
11830                 case 0x40:
11831                 case 0x50:
11832                 case 0x60:
11833                 case 0x70:
11834                 case 0x80:
11835                 case 0x90:
11836                 case 0xa0:
11837                 case 0xb0:
11838                 case 0xc0:
11839                 case 0xd0:
11840                 case 0xe0:
11841                   goto op_semantics_93;
11842                   break;
11843                 case 0xf0:
11844                   goto op_semantics_94;
11845                   break;
11846               }
11847             break;
11848           case 0xe4:
11849               GETBYTE ();
11850               switch (op[2] & 0xf0)
11851               {
11852                 case 0x00:
11853                 case 0x10:
11854                 case 0x20:
11855                 case 0x30:
11856                 case 0x40:
11857                 case 0x50:
11858                 case 0x60:
11859                 case 0x70:
11860                 case 0x80:
11861                 case 0x90:
11862                 case 0xa0:
11863                 case 0xb0:
11864                 case 0xc0:
11865                 case 0xd0:
11866                 case 0xe0:
11867                   goto op_semantics_93;
11868                   break;
11869                 case 0xf0:
11870                   goto op_semantics_94;
11871                   break;
11872               }
11873             break;
11874           case 0xe5:
11875               GETBYTE ();
11876               switch (op[2] & 0xf0)
11877               {
11878                 case 0x00:
11879                 case 0x10:
11880                 case 0x20:
11881                 case 0x30:
11882                 case 0x40:
11883                 case 0x50:
11884                 case 0x60:
11885                 case 0x70:
11886                 case 0x80:
11887                 case 0x90:
11888                 case 0xa0:
11889                 case 0xb0:
11890                 case 0xc0:
11891                 case 0xd0:
11892                 case 0xe0:
11893                   goto op_semantics_93;
11894                   break;
11895                 case 0xf0:
11896                   goto op_semantics_94;
11897                   break;
11898               }
11899             break;
11900           case 0xe6:
11901               GETBYTE ();
11902               switch (op[2] & 0xf0)
11903               {
11904                 case 0x00:
11905                 case 0x10:
11906                 case 0x20:
11907                 case 0x30:
11908                 case 0x40:
11909                 case 0x50:
11910                 case 0x60:
11911                 case 0x70:
11912                 case 0x80:
11913                 case 0x90:
11914                 case 0xa0:
11915                 case 0xb0:
11916                 case 0xc0:
11917                 case 0xd0:
11918                 case 0xe0:
11919                   goto op_semantics_93;
11920                   break;
11921                 case 0xf0:
11922                   goto op_semantics_94;
11923                   break;
11924               }
11925             break;
11926           case 0xe7:
11927               GETBYTE ();
11928               switch (op[2] & 0xf0)
11929               {
11930                 case 0x00:
11931                 case 0x10:
11932                 case 0x20:
11933                 case 0x30:
11934                 case 0x40:
11935                 case 0x50:
11936                 case 0x60:
11937                 case 0x70:
11938                 case 0x80:
11939                 case 0x90:
11940                 case 0xa0:
11941                 case 0xb0:
11942                 case 0xc0:
11943                 case 0xd0:
11944                 case 0xe0:
11945                   goto op_semantics_93;
11946                   break;
11947                 case 0xf0:
11948                   goto op_semantics_94;
11949                   break;
11950               }
11951             break;
11952           case 0xe8:
11953               GETBYTE ();
11954               switch (op[2] & 0xf0)
11955               {
11956                 case 0x00:
11957                 case 0x10:
11958                 case 0x20:
11959                 case 0x30:
11960                 case 0x40:
11961                 case 0x50:
11962                 case 0x60:
11963                 case 0x70:
11964                 case 0x80:
11965                 case 0x90:
11966                 case 0xa0:
11967                 case 0xb0:
11968                 case 0xc0:
11969                 case 0xd0:
11970                 case 0xe0:
11971                   goto op_semantics_93;
11972                   break;
11973                 case 0xf0:
11974                   goto op_semantics_94;
11975                   break;
11976               }
11977             break;
11978           case 0xe9:
11979               GETBYTE ();
11980               switch (op[2] & 0xf0)
11981               {
11982                 case 0x00:
11983                 case 0x10:
11984                 case 0x20:
11985                 case 0x30:
11986                 case 0x40:
11987                 case 0x50:
11988                 case 0x60:
11989                 case 0x70:
11990                 case 0x80:
11991                 case 0x90:
11992                 case 0xa0:
11993                 case 0xb0:
11994                 case 0xc0:
11995                 case 0xd0:
11996                 case 0xe0:
11997                   goto op_semantics_93;
11998                   break;
11999                 case 0xf0:
12000                   goto op_semantics_94;
12001                   break;
12002               }
12003             break;
12004           case 0xea:
12005               GETBYTE ();
12006               switch (op[2] & 0xf0)
12007               {
12008                 case 0x00:
12009                 case 0x10:
12010                 case 0x20:
12011                 case 0x30:
12012                 case 0x40:
12013                 case 0x50:
12014                 case 0x60:
12015                 case 0x70:
12016                 case 0x80:
12017                 case 0x90:
12018                 case 0xa0:
12019                 case 0xb0:
12020                 case 0xc0:
12021                 case 0xd0:
12022                 case 0xe0:
12023                   goto op_semantics_93;
12024                   break;
12025                 case 0xf0:
12026                   goto op_semantics_94;
12027                   break;
12028               }
12029             break;
12030           case 0xeb:
12031               GETBYTE ();
12032               switch (op[2] & 0xf0)
12033               {
12034                 case 0x00:
12035                 case 0x10:
12036                 case 0x20:
12037                 case 0x30:
12038                 case 0x40:
12039                 case 0x50:
12040                 case 0x60:
12041                 case 0x70:
12042                 case 0x80:
12043                 case 0x90:
12044                 case 0xa0:
12045                 case 0xb0:
12046                 case 0xc0:
12047                 case 0xd0:
12048                 case 0xe0:
12049                   goto op_semantics_93;
12050                   break;
12051                 case 0xf0:
12052                   goto op_semantics_94;
12053                   break;
12054               }
12055             break;
12056           case 0xec:
12057               GETBYTE ();
12058               switch (op[2] & 0xf0)
12059               {
12060                 case 0x00:
12061                 case 0x10:
12062                 case 0x20:
12063                 case 0x30:
12064                 case 0x40:
12065                 case 0x50:
12066                 case 0x60:
12067                 case 0x70:
12068                 case 0x80:
12069                 case 0x90:
12070                 case 0xa0:
12071                 case 0xb0:
12072                 case 0xc0:
12073                 case 0xd0:
12074                 case 0xe0:
12075                   goto op_semantics_93;
12076                   break;
12077                 case 0xf0:
12078                   goto op_semantics_94;
12079                   break;
12080               }
12081             break;
12082           case 0xed:
12083               GETBYTE ();
12084               switch (op[2] & 0xf0)
12085               {
12086                 case 0x00:
12087                 case 0x10:
12088                 case 0x20:
12089                 case 0x30:
12090                 case 0x40:
12091                 case 0x50:
12092                 case 0x60:
12093                 case 0x70:
12094                 case 0x80:
12095                 case 0x90:
12096                 case 0xa0:
12097                 case 0xb0:
12098                 case 0xc0:
12099                 case 0xd0:
12100                 case 0xe0:
12101                   goto op_semantics_93;
12102                   break;
12103                 case 0xf0:
12104                   goto op_semantics_94;
12105                   break;
12106               }
12107             break;
12108           case 0xee:
12109               GETBYTE ();
12110               switch (op[2] & 0xf0)
12111               {
12112                 case 0x00:
12113                 case 0x10:
12114                 case 0x20:
12115                 case 0x30:
12116                 case 0x40:
12117                 case 0x50:
12118                 case 0x60:
12119                 case 0x70:
12120                 case 0x80:
12121                 case 0x90:
12122                 case 0xa0:
12123                 case 0xb0:
12124                 case 0xc0:
12125                 case 0xd0:
12126                 case 0xe0:
12127                   goto op_semantics_93;
12128                   break;
12129                 case 0xf0:
12130                   goto op_semantics_94;
12131                   break;
12132               }
12133             break;
12134           case 0xef:
12135               GETBYTE ();
12136               switch (op[2] & 0xf0)
12137               {
12138                 case 0x00:
12139                 case 0x10:
12140                 case 0x20:
12141                 case 0x30:
12142                 case 0x40:
12143                 case 0x50:
12144                 case 0x60:
12145                 case 0x70:
12146                 case 0x80:
12147                 case 0x90:
12148                 case 0xa0:
12149                 case 0xb0:
12150                 case 0xc0:
12151                 case 0xd0:
12152                 case 0xe0:
12153                   goto op_semantics_93;
12154                   break;
12155                 case 0xf0:
12156                   goto op_semantics_94;
12157                   break;
12158               }
12159             break;
12160           case 0xf0:
12161               GETBYTE ();
12162               switch (op[2] & 0xf0)
12163               {
12164                 case 0x00:
12165                 case 0x10:
12166                 case 0x20:
12167                 case 0x30:
12168                 case 0x40:
12169                 case 0x50:
12170                 case 0x60:
12171                 case 0x70:
12172                 case 0x80:
12173                 case 0x90:
12174                 case 0xa0:
12175                 case 0xb0:
12176                 case 0xc0:
12177                 case 0xd0:
12178                 case 0xe0:
12179                   goto op_semantics_93;
12180                   break;
12181                 case 0xf0:
12182                   goto op_semantics_94;
12183                   break;
12184               }
12185             break;
12186           case 0xf1:
12187               GETBYTE ();
12188               switch (op[2] & 0xf0)
12189               {
12190                 case 0x00:
12191                 case 0x10:
12192                 case 0x20:
12193                 case 0x30:
12194                 case 0x40:
12195                 case 0x50:
12196                 case 0x60:
12197                 case 0x70:
12198                 case 0x80:
12199                 case 0x90:
12200                 case 0xa0:
12201                 case 0xb0:
12202                 case 0xc0:
12203                 case 0xd0:
12204                 case 0xe0:
12205                   goto op_semantics_93;
12206                   break;
12207                 case 0xf0:
12208                   goto op_semantics_94;
12209                   break;
12210               }
12211             break;
12212           case 0xf2:
12213               GETBYTE ();
12214               switch (op[2] & 0xf0)
12215               {
12216                 case 0x00:
12217                 case 0x10:
12218                 case 0x20:
12219                 case 0x30:
12220                 case 0x40:
12221                 case 0x50:
12222                 case 0x60:
12223                 case 0x70:
12224                 case 0x80:
12225                 case 0x90:
12226                 case 0xa0:
12227                 case 0xb0:
12228                 case 0xc0:
12229                 case 0xd0:
12230                 case 0xe0:
12231                   goto op_semantics_93;
12232                   break;
12233                 case 0xf0:
12234                   goto op_semantics_94;
12235                   break;
12236               }
12237             break;
12238           case 0xf3:
12239               GETBYTE ();
12240               switch (op[2] & 0xf0)
12241               {
12242                 case 0x00:
12243                 case 0x10:
12244                 case 0x20:
12245                 case 0x30:
12246                 case 0x40:
12247                 case 0x50:
12248                 case 0x60:
12249                 case 0x70:
12250                 case 0x80:
12251                 case 0x90:
12252                 case 0xa0:
12253                 case 0xb0:
12254                 case 0xc0:
12255                 case 0xd0:
12256                 case 0xe0:
12257                   goto op_semantics_93;
12258                   break;
12259                 case 0xf0:
12260                   goto op_semantics_94;
12261                   break;
12262               }
12263             break;
12264           case 0xf4:
12265               GETBYTE ();
12266               switch (op[2] & 0xf0)
12267               {
12268                 case 0x00:
12269                 case 0x10:
12270                 case 0x20:
12271                 case 0x30:
12272                 case 0x40:
12273                 case 0x50:
12274                 case 0x60:
12275                 case 0x70:
12276                 case 0x80:
12277                 case 0x90:
12278                 case 0xa0:
12279                 case 0xb0:
12280                 case 0xc0:
12281                 case 0xd0:
12282                 case 0xe0:
12283                   goto op_semantics_93;
12284                   break;
12285                 case 0xf0:
12286                   goto op_semantics_94;
12287                   break;
12288               }
12289             break;
12290           case 0xf5:
12291               GETBYTE ();
12292               switch (op[2] & 0xf0)
12293               {
12294                 case 0x00:
12295                 case 0x10:
12296                 case 0x20:
12297                 case 0x30:
12298                 case 0x40:
12299                 case 0x50:
12300                 case 0x60:
12301                 case 0x70:
12302                 case 0x80:
12303                 case 0x90:
12304                 case 0xa0:
12305                 case 0xb0:
12306                 case 0xc0:
12307                 case 0xd0:
12308                 case 0xe0:
12309                   goto op_semantics_93;
12310                   break;
12311                 case 0xf0:
12312                   goto op_semantics_94;
12313                   break;
12314               }
12315             break;
12316           case 0xf6:
12317               GETBYTE ();
12318               switch (op[2] & 0xf0)
12319               {
12320                 case 0x00:
12321                 case 0x10:
12322                 case 0x20:
12323                 case 0x30:
12324                 case 0x40:
12325                 case 0x50:
12326                 case 0x60:
12327                 case 0x70:
12328                 case 0x80:
12329                 case 0x90:
12330                 case 0xa0:
12331                 case 0xb0:
12332                 case 0xc0:
12333                 case 0xd0:
12334                 case 0xe0:
12335                   goto op_semantics_93;
12336                   break;
12337                 case 0xf0:
12338                   goto op_semantics_94;
12339                   break;
12340               }
12341             break;
12342           case 0xf7:
12343               GETBYTE ();
12344               switch (op[2] & 0xf0)
12345               {
12346                 case 0x00:
12347                 case 0x10:
12348                 case 0x20:
12349                 case 0x30:
12350                 case 0x40:
12351                 case 0x50:
12352                 case 0x60:
12353                 case 0x70:
12354                 case 0x80:
12355                 case 0x90:
12356                 case 0xa0:
12357                 case 0xb0:
12358                 case 0xc0:
12359                 case 0xd0:
12360                 case 0xe0:
12361                   goto op_semantics_93;
12362                   break;
12363                 case 0xf0:
12364                   goto op_semantics_94;
12365                   break;
12366               }
12367             break;
12368           case 0xf8:
12369               GETBYTE ();
12370               switch (op[2] & 0xf0)
12371               {
12372                 case 0x00:
12373                 case 0x10:
12374                 case 0x20:
12375                 case 0x30:
12376                 case 0x40:
12377                 case 0x50:
12378                 case 0x60:
12379                 case 0x70:
12380                 case 0x80:
12381                 case 0x90:
12382                 case 0xa0:
12383                 case 0xb0:
12384                 case 0xc0:
12385                 case 0xd0:
12386                 case 0xe0:
12387                   goto op_semantics_93;
12388                   break;
12389                 case 0xf0:
12390                   goto op_semantics_94;
12391                   break;
12392               }
12393             break;
12394           case 0xf9:
12395               GETBYTE ();
12396               switch (op[2] & 0xf0)
12397               {
12398                 case 0x00:
12399                 case 0x10:
12400                 case 0x20:
12401                 case 0x30:
12402                 case 0x40:
12403                 case 0x50:
12404                 case 0x60:
12405                 case 0x70:
12406                 case 0x80:
12407                 case 0x90:
12408                 case 0xa0:
12409                 case 0xb0:
12410                 case 0xc0:
12411                 case 0xd0:
12412                 case 0xe0:
12413                   goto op_semantics_93;
12414                   break;
12415                 case 0xf0:
12416                   goto op_semantics_94;
12417                   break;
12418               }
12419             break;
12420           case 0xfa:
12421               GETBYTE ();
12422               switch (op[2] & 0xf0)
12423               {
12424                 case 0x00:
12425                 case 0x10:
12426                 case 0x20:
12427                 case 0x30:
12428                 case 0x40:
12429                 case 0x50:
12430                 case 0x60:
12431                 case 0x70:
12432                 case 0x80:
12433                 case 0x90:
12434                 case 0xa0:
12435                 case 0xb0:
12436                 case 0xc0:
12437                 case 0xd0:
12438                 case 0xe0:
12439                   goto op_semantics_93;
12440                   break;
12441                 case 0xf0:
12442                   goto op_semantics_94;
12443                   break;
12444               }
12445             break;
12446           case 0xfb:
12447               GETBYTE ();
12448               switch (op[2] & 0xf0)
12449               {
12450                 case 0x00:
12451                 case 0x10:
12452                 case 0x20:
12453                 case 0x30:
12454                 case 0x40:
12455                 case 0x50:
12456                 case 0x60:
12457                 case 0x70:
12458                 case 0x80:
12459                 case 0x90:
12460                 case 0xa0:
12461                 case 0xb0:
12462                 case 0xc0:
12463                 case 0xd0:
12464                 case 0xe0:
12465                   goto op_semantics_93;
12466                   break;
12467                 case 0xf0:
12468                   goto op_semantics_94;
12469                   break;
12470               }
12471             break;
12472           case 0xfc:
12473               GETBYTE ();
12474               switch (op[2] & 0xf0)
12475               {
12476                 case 0x00:
12477                 case 0x10:
12478                 case 0x20:
12479                 case 0x30:
12480                 case 0x40:
12481                 case 0x50:
12482                 case 0x60:
12483                 case 0x70:
12484                 case 0x80:
12485                 case 0x90:
12486                 case 0xa0:
12487                 case 0xb0:
12488                 case 0xc0:
12489                 case 0xd0:
12490                 case 0xe0:
12491                   goto op_semantics_93;
12492                   break;
12493                 case 0xf0:
12494                   goto op_semantics_94;
12495                   break;
12496               }
12497             break;
12498           case 0xfd:
12499               GETBYTE ();
12500               switch (op[2] & 0xf0)
12501               {
12502                 case 0x00:
12503                 case 0x10:
12504                 case 0x20:
12505                 case 0x30:
12506                 case 0x40:
12507                 case 0x50:
12508                 case 0x60:
12509                 case 0x70:
12510                 case 0x80:
12511                 case 0x90:
12512                 case 0xa0:
12513                 case 0xb0:
12514                 case 0xc0:
12515                 case 0xd0:
12516                 case 0xe0:
12517                   goto op_semantics_93;
12518                   break;
12519                 case 0xf0:
12520                   goto op_semantics_94;
12521                   break;
12522               }
12523             break;
12524           case 0xfe:
12525               GETBYTE ();
12526               switch (op[2] & 0xf0)
12527               {
12528                 case 0x00:
12529                 case 0x10:
12530                 case 0x20:
12531                 case 0x30:
12532                 case 0x40:
12533                 case 0x50:
12534                 case 0x60:
12535                 case 0x70:
12536                 case 0x80:
12537                 case 0x90:
12538                 case 0xa0:
12539                 case 0xb0:
12540                 case 0xc0:
12541                 case 0xd0:
12542                 case 0xe0:
12543                   goto op_semantics_93;
12544                   break;
12545                 case 0xf0:
12546                   goto op_semantics_94;
12547                   break;
12548               }
12549             break;
12550           case 0xff:
12551               GETBYTE ();
12552               switch (op[2] & 0xf0)
12553               {
12554                 case 0x00:
12555                 case 0x10:
12556                 case 0x20:
12557                 case 0x30:
12558                 case 0x40:
12559                 case 0x50:
12560                 case 0x60:
12561                 case 0x70:
12562                 case 0x80:
12563                 case 0x90:
12564                 case 0xa0:
12565                 case 0xb0:
12566                 case 0xc0:
12567                 case 0xd0:
12568                 case 0xe0:
12569                   goto op_semantics_93;
12570                   break;
12571                 case 0xf0:
12572                   goto op_semantics_94;
12573                   break;
12574               }
12575             break;
12576           default: UNSUPPORTED(); break;
12577         }
12578       break;
12579     case 0xfe:
12580         GETBYTE ();
12581         switch (op[1] & 0xff)
12582         {
12583           case 0x00:
12584               GETBYTE ();
12585               switch (op[2] & 0x00)
12586               {
12587                 case 0x00:
12588                   op_semantics_95:
12589                     {
12590                       /** 1111 1110 00sz isrc bsrc rdst mov%s   %0, [%1, %2] */
12591 #line 317 "/work/sources/gcc/current/opcodes/rx-decode.opc"
12592                       int sz AU = (op[1] >> 4) & 0x03;
12593 #line 317 "/work/sources/gcc/current/opcodes/rx-decode.opc"
12594                       int isrc AU = op[1] & 0x0f;
12595 #line 317 "/work/sources/gcc/current/opcodes/rx-decode.opc"
12596                       int bsrc AU = (op[2] >> 4) & 0x0f;
12597 #line 317 "/work/sources/gcc/current/opcodes/rx-decode.opc"
12598                       int rdst AU = op[2] & 0x0f;
12599                       if (trace)
12600                         {
12601                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12602                                  "/** 1111 1110 00sz isrc bsrc rdst     mov%s   %0, [%1, %2] */",
12603                                  op[0], op[1], op[2]);
12604                           printf ("  sz = 0x%x,", sz);
12605                           printf ("  isrc = 0x%x,", isrc);
12606                           printf ("  bsrc = 0x%x,", bsrc);
12607                           printf ("  rdst = 0x%x\n", rdst);
12608                         }
12609                       SYNTAX("mov%s     %0, [%1, %2]");
12610 #line 318 "/work/sources/gcc/current/opcodes/rx-decode.opc"
12611                       ID(movbir); sBWL(sz); DR(rdst); SR(isrc); S2R(bsrc); F("----");
12612
12613                     }
12614                   break;
12615               }
12616             break;
12617           case 0x01:
12618               GETBYTE ();
12619               switch (op[2] & 0x00)
12620               {
12621                 case 0x00:
12622                   goto op_semantics_95;
12623                   break;
12624               }
12625             break;
12626           case 0x02:
12627               GETBYTE ();
12628               switch (op[2] & 0x00)
12629               {
12630                 case 0x00:
12631                   goto op_semantics_95;
12632                   break;
12633               }
12634             break;
12635           case 0x03:
12636               GETBYTE ();
12637               switch (op[2] & 0x00)
12638               {
12639                 case 0x00:
12640                   goto op_semantics_95;
12641                   break;
12642               }
12643             break;
12644           case 0x04:
12645               GETBYTE ();
12646               switch (op[2] & 0x00)
12647               {
12648                 case 0x00:
12649                   goto op_semantics_95;
12650                   break;
12651               }
12652             break;
12653           case 0x05:
12654               GETBYTE ();
12655               switch (op[2] & 0x00)
12656               {
12657                 case 0x00:
12658                   goto op_semantics_95;
12659                   break;
12660               }
12661             break;
12662           case 0x06:
12663               GETBYTE ();
12664               switch (op[2] & 0x00)
12665               {
12666                 case 0x00:
12667                   goto op_semantics_95;
12668                   break;
12669               }
12670             break;
12671           case 0x07:
12672               GETBYTE ();
12673               switch (op[2] & 0x00)
12674               {
12675                 case 0x00:
12676                   goto op_semantics_95;
12677                   break;
12678               }
12679             break;
12680           case 0x08:
12681               GETBYTE ();
12682               switch (op[2] & 0x00)
12683               {
12684                 case 0x00:
12685                   goto op_semantics_95;
12686                   break;
12687               }
12688             break;
12689           case 0x09:
12690               GETBYTE ();
12691               switch (op[2] & 0x00)
12692               {
12693                 case 0x00:
12694                   goto op_semantics_95;
12695                   break;
12696               }
12697             break;
12698           case 0x0a:
12699               GETBYTE ();
12700               switch (op[2] & 0x00)
12701               {
12702                 case 0x00:
12703                   goto op_semantics_95;
12704                   break;
12705               }
12706             break;
12707           case 0x0b:
12708               GETBYTE ();
12709               switch (op[2] & 0x00)
12710               {
12711                 case 0x00:
12712                   goto op_semantics_95;
12713                   break;
12714               }
12715             break;
12716           case 0x0c:
12717               GETBYTE ();
12718               switch (op[2] & 0x00)
12719               {
12720                 case 0x00:
12721                   goto op_semantics_95;
12722                   break;
12723               }
12724             break;
12725           case 0x0d:
12726               GETBYTE ();
12727               switch (op[2] & 0x00)
12728               {
12729                 case 0x00:
12730                   goto op_semantics_95;
12731                   break;
12732               }
12733             break;
12734           case 0x0e:
12735               GETBYTE ();
12736               switch (op[2] & 0x00)
12737               {
12738                 case 0x00:
12739                   goto op_semantics_95;
12740                   break;
12741               }
12742             break;
12743           case 0x0f:
12744               GETBYTE ();
12745               switch (op[2] & 0x00)
12746               {
12747                 case 0x00:
12748                   goto op_semantics_95;
12749                   break;
12750               }
12751             break;
12752           case 0x10:
12753               GETBYTE ();
12754               switch (op[2] & 0x00)
12755               {
12756                 case 0x00:
12757                   goto op_semantics_95;
12758                   break;
12759               }
12760             break;
12761           case 0x11:
12762               GETBYTE ();
12763               switch (op[2] & 0x00)
12764               {
12765                 case 0x00:
12766                   goto op_semantics_95;
12767                   break;
12768               }
12769             break;
12770           case 0x12:
12771               GETBYTE ();
12772               switch (op[2] & 0x00)
12773               {
12774                 case 0x00:
12775                   goto op_semantics_95;
12776                   break;
12777               }
12778             break;
12779           case 0x13:
12780               GETBYTE ();
12781               switch (op[2] & 0x00)
12782               {
12783                 case 0x00:
12784                   goto op_semantics_95;
12785                   break;
12786               }
12787             break;
12788           case 0x14:
12789               GETBYTE ();
12790               switch (op[2] & 0x00)
12791               {
12792                 case 0x00:
12793                   goto op_semantics_95;
12794                   break;
12795               }
12796             break;
12797           case 0x15:
12798               GETBYTE ();
12799               switch (op[2] & 0x00)
12800               {
12801                 case 0x00:
12802                   goto op_semantics_95;
12803                   break;
12804               }
12805             break;
12806           case 0x16:
12807               GETBYTE ();
12808               switch (op[2] & 0x00)
12809               {
12810                 case 0x00:
12811                   goto op_semantics_95;
12812                   break;
12813               }
12814             break;
12815           case 0x17:
12816               GETBYTE ();
12817               switch (op[2] & 0x00)
12818               {
12819                 case 0x00:
12820                   goto op_semantics_95;
12821                   break;
12822               }
12823             break;
12824           case 0x18:
12825               GETBYTE ();
12826               switch (op[2] & 0x00)
12827               {
12828                 case 0x00:
12829                   goto op_semantics_95;
12830                   break;
12831               }
12832             break;
12833           case 0x19:
12834               GETBYTE ();
12835               switch (op[2] & 0x00)
12836               {
12837                 case 0x00:
12838                   goto op_semantics_95;
12839                   break;
12840               }
12841             break;
12842           case 0x1a:
12843               GETBYTE ();
12844               switch (op[2] & 0x00)
12845               {
12846                 case 0x00:
12847                   goto op_semantics_95;
12848                   break;
12849               }
12850             break;
12851           case 0x1b:
12852               GETBYTE ();
12853               switch (op[2] & 0x00)
12854               {
12855                 case 0x00:
12856                   goto op_semantics_95;
12857                   break;
12858               }
12859             break;
12860           case 0x1c:
12861               GETBYTE ();
12862               switch (op[2] & 0x00)
12863               {
12864                 case 0x00:
12865                   goto op_semantics_95;
12866                   break;
12867               }
12868             break;
12869           case 0x1d:
12870               GETBYTE ();
12871               switch (op[2] & 0x00)
12872               {
12873                 case 0x00:
12874                   goto op_semantics_95;
12875                   break;
12876               }
12877             break;
12878           case 0x1e:
12879               GETBYTE ();
12880               switch (op[2] & 0x00)
12881               {
12882                 case 0x00:
12883                   goto op_semantics_95;
12884                   break;
12885               }
12886             break;
12887           case 0x1f:
12888               GETBYTE ();
12889               switch (op[2] & 0x00)
12890               {
12891                 case 0x00:
12892                   goto op_semantics_95;
12893                   break;
12894               }
12895             break;
12896           case 0x20:
12897               GETBYTE ();
12898               switch (op[2] & 0x00)
12899               {
12900                 case 0x00:
12901                   goto op_semantics_95;
12902                   break;
12903               }
12904             break;
12905           case 0x21:
12906               GETBYTE ();
12907               switch (op[2] & 0x00)
12908               {
12909                 case 0x00:
12910                   goto op_semantics_95;
12911                   break;
12912               }
12913             break;
12914           case 0x22:
12915               GETBYTE ();
12916               switch (op[2] & 0x00)
12917               {
12918                 case 0x00:
12919                   goto op_semantics_95;
12920                   break;
12921               }
12922             break;
12923           case 0x23:
12924               GETBYTE ();
12925               switch (op[2] & 0x00)
12926               {
12927                 case 0x00:
12928                   goto op_semantics_95;
12929                   break;
12930               }
12931             break;
12932           case 0x24:
12933               GETBYTE ();
12934               switch (op[2] & 0x00)
12935               {
12936                 case 0x00:
12937                   goto op_semantics_95;
12938                   break;
12939               }
12940             break;
12941           case 0x25:
12942               GETBYTE ();
12943               switch (op[2] & 0x00)
12944               {
12945                 case 0x00:
12946                   goto op_semantics_95;
12947                   break;
12948               }
12949             break;
12950           case 0x26:
12951               GETBYTE ();
12952               switch (op[2] & 0x00)
12953               {
12954                 case 0x00:
12955                   goto op_semantics_95;
12956                   break;
12957               }
12958             break;
12959           case 0x27:
12960               GETBYTE ();
12961               switch (op[2] & 0x00)
12962               {
12963                 case 0x00:
12964                   goto op_semantics_95;
12965                   break;
12966               }
12967             break;
12968           case 0x28:
12969               GETBYTE ();
12970               switch (op[2] & 0x00)
12971               {
12972                 case 0x00:
12973                   goto op_semantics_95;
12974                   break;
12975               }
12976             break;
12977           case 0x29:
12978               GETBYTE ();
12979               switch (op[2] & 0x00)
12980               {
12981                 case 0x00:
12982                   goto op_semantics_95;
12983                   break;
12984               }
12985             break;
12986           case 0x2a:
12987               GETBYTE ();
12988               switch (op[2] & 0x00)
12989               {
12990                 case 0x00:
12991                   goto op_semantics_95;
12992                   break;
12993               }
12994             break;
12995           case 0x2b:
12996               GETBYTE ();
12997               switch (op[2] & 0x00)
12998               {
12999                 case 0x00:
13000                   goto op_semantics_95;
13001                   break;
13002               }
13003             break;
13004           case 0x2c:
13005               GETBYTE ();
13006               switch (op[2] & 0x00)
13007               {
13008                 case 0x00:
13009                   goto op_semantics_95;
13010                   break;
13011               }
13012             break;
13013           case 0x2d:
13014               GETBYTE ();
13015               switch (op[2] & 0x00)
13016               {
13017                 case 0x00:
13018                   goto op_semantics_95;
13019                   break;
13020               }
13021             break;
13022           case 0x2e:
13023               GETBYTE ();
13024               switch (op[2] & 0x00)
13025               {
13026                 case 0x00:
13027                   goto op_semantics_95;
13028                   break;
13029               }
13030             break;
13031           case 0x2f:
13032               GETBYTE ();
13033               switch (op[2] & 0x00)
13034               {
13035                 case 0x00:
13036                   goto op_semantics_95;
13037                   break;
13038               }
13039             break;
13040           case 0x40:
13041               GETBYTE ();
13042               switch (op[2] & 0x00)
13043               {
13044                 case 0x00:
13045                   op_semantics_96:
13046                     {
13047                       /** 1111 1110 01sz isrc bsrc rdst mov%s   [%1, %2], %0 */
13048 #line 314 "/work/sources/gcc/current/opcodes/rx-decode.opc"
13049                       int sz AU = (op[1] >> 4) & 0x03;
13050 #line 314 "/work/sources/gcc/current/opcodes/rx-decode.opc"
13051                       int isrc AU = op[1] & 0x0f;
13052 #line 314 "/work/sources/gcc/current/opcodes/rx-decode.opc"
13053                       int bsrc AU = (op[2] >> 4) & 0x0f;
13054 #line 314 "/work/sources/gcc/current/opcodes/rx-decode.opc"
13055                       int rdst AU = op[2] & 0x0f;
13056                       if (trace)
13057                         {
13058                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13059                                  "/** 1111 1110 01sz isrc bsrc rdst     mov%s   [%1, %2], %0 */",
13060                                  op[0], op[1], op[2]);
13061                           printf ("  sz = 0x%x,", sz);
13062                           printf ("  isrc = 0x%x,", isrc);
13063                           printf ("  bsrc = 0x%x,", bsrc);
13064                           printf ("  rdst = 0x%x\n", rdst);
13065                         }
13066                       SYNTAX("mov%s     [%1, %2], %0");
13067 #line 315 "/work/sources/gcc/current/opcodes/rx-decode.opc"
13068                       ID(movbi); sBWL(sz); DR(rdst); SR(isrc); S2R(bsrc); F("----");
13069
13070                     }
13071                   break;
13072               }
13073             break;
13074           case 0x41:
13075               GETBYTE ();
13076               switch (op[2] & 0x00)
13077               {
13078                 case 0x00:
13079                   goto op_semantics_96;
13080                   break;
13081               }
13082             break;
13083           case 0x42:
13084               GETBYTE ();
13085               switch (op[2] & 0x00)
13086               {
13087                 case 0x00:
13088                   goto op_semantics_96;
13089                   break;
13090               }
13091             break;
13092           case 0x43:
13093               GETBYTE ();
13094               switch (op[2] & 0x00)
13095               {
13096                 case 0x00:
13097                   goto op_semantics_96;
13098                   break;
13099               }
13100             break;
13101           case 0x44:
13102               GETBYTE ();
13103               switch (op[2] & 0x00)
13104               {
13105                 case 0x00:
13106                   goto op_semantics_96;
13107                   break;
13108               }
13109             break;
13110           case 0x45:
13111               GETBYTE ();
13112               switch (op[2] & 0x00)
13113               {
13114                 case 0x00:
13115                   goto op_semantics_96;
13116                   break;
13117               }
13118             break;
13119           case 0x46:
13120               GETBYTE ();
13121               switch (op[2] & 0x00)
13122               {
13123                 case 0x00:
13124                   goto op_semantics_96;
13125                   break;
13126               }
13127             break;
13128           case 0x47:
13129               GETBYTE ();
13130               switch (op[2] & 0x00)
13131               {
13132                 case 0x00:
13133                   goto op_semantics_96;
13134                   break;
13135               }
13136             break;
13137           case 0x48:
13138               GETBYTE ();
13139               switch (op[2] & 0x00)
13140               {
13141                 case 0x00:
13142                   goto op_semantics_96;
13143                   break;
13144               }
13145             break;
13146           case 0x49:
13147               GETBYTE ();
13148               switch (op[2] & 0x00)
13149               {
13150                 case 0x00:
13151                   goto op_semantics_96;
13152                   break;
13153               }
13154             break;
13155           case 0x4a:
13156               GETBYTE ();
13157               switch (op[2] & 0x00)
13158               {
13159                 case 0x00:
13160                   goto op_semantics_96;
13161                   break;
13162               }
13163             break;
13164           case 0x4b:
13165               GETBYTE ();
13166               switch (op[2] & 0x00)
13167               {
13168                 case 0x00:
13169                   goto op_semantics_96;
13170                   break;
13171               }
13172             break;
13173           case 0x4c:
13174               GETBYTE ();
13175               switch (op[2] & 0x00)
13176               {
13177                 case 0x00:
13178                   goto op_semantics_96;
13179                   break;
13180               }
13181             break;
13182           case 0x4d:
13183               GETBYTE ();
13184               switch (op[2] & 0x00)
13185               {
13186                 case 0x00:
13187                   goto op_semantics_96;
13188                   break;
13189               }
13190             break;
13191           case 0x4e:
13192               GETBYTE ();
13193               switch (op[2] & 0x00)
13194               {
13195                 case 0x00:
13196                   goto op_semantics_96;
13197                   break;
13198               }
13199             break;
13200           case 0x4f:
13201               GETBYTE ();
13202               switch (op[2] & 0x00)
13203               {
13204                 case 0x00:
13205                   goto op_semantics_96;
13206                   break;
13207               }
13208             break;
13209           case 0x50:
13210               GETBYTE ();
13211               switch (op[2] & 0x00)
13212               {
13213                 case 0x00:
13214                   goto op_semantics_96;
13215                   break;
13216               }
13217             break;
13218           case 0x51:
13219               GETBYTE ();
13220               switch (op[2] & 0x00)
13221               {
13222                 case 0x00:
13223                   goto op_semantics_96;
13224                   break;
13225               }
13226             break;
13227           case 0x52:
13228               GETBYTE ();
13229               switch (op[2] & 0x00)
13230               {
13231                 case 0x00:
13232                   goto op_semantics_96;
13233                   break;
13234               }
13235             break;
13236           case 0x53:
13237               GETBYTE ();
13238               switch (op[2] & 0x00)
13239               {
13240                 case 0x00:
13241                   goto op_semantics_96;
13242                   break;
13243               }
13244             break;
13245           case 0x54:
13246               GETBYTE ();
13247               switch (op[2] & 0x00)
13248               {
13249                 case 0x00:
13250                   goto op_semantics_96;
13251                   break;
13252               }
13253             break;
13254           case 0x55:
13255               GETBYTE ();
13256               switch (op[2] & 0x00)
13257               {
13258                 case 0x00:
13259                   goto op_semantics_96;
13260                   break;
13261               }
13262             break;
13263           case 0x56:
13264               GETBYTE ();
13265               switch (op[2] & 0x00)
13266               {
13267                 case 0x00:
13268                   goto op_semantics_96;
13269                   break;
13270               }
13271             break;
13272           case 0x57:
13273               GETBYTE ();
13274               switch (op[2] & 0x00)
13275               {
13276                 case 0x00:
13277                   goto op_semantics_96;
13278                   break;
13279               }
13280             break;
13281           case 0x58:
13282               GETBYTE ();
13283               switch (op[2] & 0x00)
13284               {
13285                 case 0x00:
13286                   goto op_semantics_96;
13287                   break;
13288               }
13289             break;
13290           case 0x59:
13291               GETBYTE ();
13292               switch (op[2] & 0x00)
13293               {
13294                 case 0x00:
13295                   goto op_semantics_96;
13296                   break;
13297               }
13298             break;
13299           case 0x5a:
13300               GETBYTE ();
13301               switch (op[2] & 0x00)
13302               {
13303                 case 0x00:
13304                   goto op_semantics_96;
13305                   break;
13306               }
13307             break;
13308           case 0x5b:
13309               GETBYTE ();
13310               switch (op[2] & 0x00)
13311               {
13312                 case 0x00:
13313                   goto op_semantics_96;
13314                   break;
13315               }
13316             break;
13317           case 0x5c:
13318               GETBYTE ();
13319               switch (op[2] & 0x00)
13320               {
13321                 case 0x00:
13322                   goto op_semantics_96;
13323                   break;
13324               }
13325             break;
13326           case 0x5d:
13327               GETBYTE ();
13328               switch (op[2] & 0x00)
13329               {
13330                 case 0x00:
13331                   goto op_semantics_96;
13332                   break;
13333               }
13334             break;
13335           case 0x5e:
13336               GETBYTE ();
13337               switch (op[2] & 0x00)
13338               {
13339                 case 0x00:
13340                   goto op_semantics_96;
13341                   break;
13342               }
13343             break;
13344           case 0x5f:
13345               GETBYTE ();
13346               switch (op[2] & 0x00)
13347               {
13348                 case 0x00:
13349                   goto op_semantics_96;
13350                   break;
13351               }
13352             break;
13353           case 0x60:
13354               GETBYTE ();
13355               switch (op[2] & 0x00)
13356               {
13357                 case 0x00:
13358                   goto op_semantics_96;
13359                   break;
13360               }
13361             break;
13362           case 0x61:
13363               GETBYTE ();
13364               switch (op[2] & 0x00)
13365               {
13366                 case 0x00:
13367                   goto op_semantics_96;
13368                   break;
13369               }
13370             break;
13371           case 0x62:
13372               GETBYTE ();
13373               switch (op[2] & 0x00)
13374               {
13375                 case 0x00:
13376                   goto op_semantics_96;
13377                   break;
13378               }
13379             break;
13380           case 0x63:
13381               GETBYTE ();
13382               switch (op[2] & 0x00)
13383               {
13384                 case 0x00:
13385                   goto op_semantics_96;
13386                   break;
13387               }
13388             break;
13389           case 0x64:
13390               GETBYTE ();
13391               switch (op[2] & 0x00)
13392               {
13393                 case 0x00:
13394                   goto op_semantics_96;
13395                   break;
13396               }
13397             break;
13398           case 0x65:
13399               GETBYTE ();
13400               switch (op[2] & 0x00)
13401               {
13402                 case 0x00:
13403                   goto op_semantics_96;
13404                   break;
13405               }
13406             break;
13407           case 0x66:
13408               GETBYTE ();
13409               switch (op[2] & 0x00)
13410               {
13411                 case 0x00:
13412                   goto op_semantics_96;
13413                   break;
13414               }
13415             break;
13416           case 0x67:
13417               GETBYTE ();
13418               switch (op[2] & 0x00)
13419               {
13420                 case 0x00:
13421                   goto op_semantics_96;
13422                   break;
13423               }
13424             break;
13425           case 0x68:
13426               GETBYTE ();
13427               switch (op[2] & 0x00)
13428               {
13429                 case 0x00:
13430                   goto op_semantics_96;
13431                   break;
13432               }
13433             break;
13434           case 0x69:
13435               GETBYTE ();
13436               switch (op[2] & 0x00)
13437               {
13438                 case 0x00:
13439                   goto op_semantics_96;
13440                   break;
13441               }
13442             break;
13443           case 0x6a:
13444               GETBYTE ();
13445               switch (op[2] & 0x00)
13446               {
13447                 case 0x00:
13448                   goto op_semantics_96;
13449                   break;
13450               }
13451             break;
13452           case 0x6b:
13453               GETBYTE ();
13454               switch (op[2] & 0x00)
13455               {
13456                 case 0x00:
13457                   goto op_semantics_96;
13458                   break;
13459               }
13460             break;
13461           case 0x6c:
13462               GETBYTE ();
13463               switch (op[2] & 0x00)
13464               {
13465                 case 0x00:
13466                   goto op_semantics_96;
13467                   break;
13468               }
13469             break;
13470           case 0x6d:
13471               GETBYTE ();
13472               switch (op[2] & 0x00)
13473               {
13474                 case 0x00:
13475                   goto op_semantics_96;
13476                   break;
13477               }
13478             break;
13479           case 0x6e:
13480               GETBYTE ();
13481               switch (op[2] & 0x00)
13482               {
13483                 case 0x00:
13484                   goto op_semantics_96;
13485                   break;
13486               }
13487             break;
13488           case 0x6f:
13489               GETBYTE ();
13490               switch (op[2] & 0x00)
13491               {
13492                 case 0x00:
13493                   goto op_semantics_96;
13494                   break;
13495               }
13496             break;
13497           case 0xc0:
13498               GETBYTE ();
13499               switch (op[2] & 0x00)
13500               {
13501                 case 0x00:
13502                   op_semantics_97:
13503                     {
13504                       /** 1111 1110 11sz isrc bsrc rdst movu%s  [%1, %2], %0 */
13505 #line 320 "/work/sources/gcc/current/opcodes/rx-decode.opc"
13506                       int sz AU = (op[1] >> 4) & 0x03;
13507 #line 320 "/work/sources/gcc/current/opcodes/rx-decode.opc"
13508                       int isrc AU = op[1] & 0x0f;
13509 #line 320 "/work/sources/gcc/current/opcodes/rx-decode.opc"
13510                       int bsrc AU = (op[2] >> 4) & 0x0f;
13511 #line 320 "/work/sources/gcc/current/opcodes/rx-decode.opc"
13512                       int rdst AU = op[2] & 0x0f;
13513                       if (trace)
13514                         {
13515                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13516                                  "/** 1111 1110 11sz isrc bsrc rdst     movu%s  [%1, %2], %0 */",
13517                                  op[0], op[1], op[2]);
13518                           printf ("  sz = 0x%x,", sz);
13519                           printf ("  isrc = 0x%x,", isrc);
13520                           printf ("  bsrc = 0x%x,", bsrc);
13521                           printf ("  rdst = 0x%x\n", rdst);
13522                         }
13523                       SYNTAX("movu%s    [%1, %2], %0");
13524 #line 321 "/work/sources/gcc/current/opcodes/rx-decode.opc"
13525                       ID(movbi); uBWL(sz); DR(rdst); SR(isrc); S2R(bsrc); F("----");
13526
13527                     }
13528                   break;
13529               }
13530             break;
13531           case 0xc1:
13532               GETBYTE ();
13533               switch (op[2] & 0x00)
13534               {
13535                 case 0x00:
13536                   goto op_semantics_97;
13537                   break;
13538               }
13539             break;
13540           case 0xc2:
13541               GETBYTE ();
13542               switch (op[2] & 0x00)
13543               {
13544                 case 0x00:
13545                   goto op_semantics_97;
13546                   break;
13547               }
13548             break;
13549           case 0xc3:
13550               GETBYTE ();
13551               switch (op[2] & 0x00)
13552               {
13553                 case 0x00:
13554                   goto op_semantics_97;
13555                   break;
13556               }
13557             break;
13558           case 0xc4:
13559               GETBYTE ();
13560               switch (op[2] & 0x00)
13561               {
13562                 case 0x00:
13563                   goto op_semantics_97;
13564                   break;
13565               }
13566             break;
13567           case 0xc5:
13568               GETBYTE ();
13569               switch (op[2] & 0x00)
13570               {
13571                 case 0x00:
13572                   goto op_semantics_97;
13573                   break;
13574               }
13575             break;
13576           case 0xc6:
13577               GETBYTE ();
13578               switch (op[2] & 0x00)
13579               {
13580                 case 0x00:
13581                   goto op_semantics_97;
13582                   break;
13583               }
13584             break;
13585           case 0xc7:
13586               GETBYTE ();
13587               switch (op[2] & 0x00)
13588               {
13589                 case 0x00:
13590                   goto op_semantics_97;
13591                   break;
13592               }
13593             break;
13594           case 0xc8:
13595               GETBYTE ();
13596               switch (op[2] & 0x00)
13597               {
13598                 case 0x00:
13599                   goto op_semantics_97;
13600                   break;
13601               }
13602             break;
13603           case 0xc9:
13604               GETBYTE ();
13605               switch (op[2] & 0x00)
13606               {
13607                 case 0x00:
13608                   goto op_semantics_97;
13609                   break;
13610               }
13611             break;
13612           case 0xca:
13613               GETBYTE ();
13614               switch (op[2] & 0x00)
13615               {
13616                 case 0x00:
13617                   goto op_semantics_97;
13618                   break;
13619               }
13620             break;
13621           case 0xcb:
13622               GETBYTE ();
13623               switch (op[2] & 0x00)
13624               {
13625                 case 0x00:
13626                   goto op_semantics_97;
13627                   break;
13628               }
13629             break;
13630           case 0xcc:
13631               GETBYTE ();
13632               switch (op[2] & 0x00)
13633               {
13634                 case 0x00:
13635                   goto op_semantics_97;
13636                   break;
13637               }
13638             break;
13639           case 0xcd:
13640               GETBYTE ();
13641               switch (op[2] & 0x00)
13642               {
13643                 case 0x00:
13644                   goto op_semantics_97;
13645                   break;
13646               }
13647             break;
13648           case 0xce:
13649               GETBYTE ();
13650               switch (op[2] & 0x00)
13651               {
13652                 case 0x00:
13653                   goto op_semantics_97;
13654                   break;
13655               }
13656             break;
13657           case 0xcf:
13658               GETBYTE ();
13659               switch (op[2] & 0x00)
13660               {
13661                 case 0x00:
13662                   goto op_semantics_97;
13663                   break;
13664               }
13665             break;
13666           case 0xd0:
13667               GETBYTE ();
13668               switch (op[2] & 0x00)
13669               {
13670                 case 0x00:
13671                   goto op_semantics_97;
13672                   break;
13673               }
13674             break;
13675           case 0xd1:
13676               GETBYTE ();
13677               switch (op[2] & 0x00)
13678               {
13679                 case 0x00:
13680                   goto op_semantics_97;
13681                   break;
13682               }
13683             break;
13684           case 0xd2:
13685               GETBYTE ();
13686               switch (op[2] & 0x00)
13687               {
13688                 case 0x00:
13689                   goto op_semantics_97;
13690                   break;
13691               }
13692             break;
13693           case 0xd3:
13694               GETBYTE ();
13695               switch (op[2] & 0x00)
13696               {
13697                 case 0x00:
13698                   goto op_semantics_97;
13699                   break;
13700               }
13701             break;
13702           case 0xd4:
13703               GETBYTE ();
13704               switch (op[2] & 0x00)
13705               {
13706                 case 0x00:
13707                   goto op_semantics_97;
13708                   break;
13709               }
13710             break;
13711           case 0xd5:
13712               GETBYTE ();
13713               switch (op[2] & 0x00)
13714               {
13715                 case 0x00:
13716                   goto op_semantics_97;
13717                   break;
13718               }
13719             break;
13720           case 0xd6:
13721               GETBYTE ();
13722               switch (op[2] & 0x00)
13723               {
13724                 case 0x00:
13725                   goto op_semantics_97;
13726                   break;
13727               }
13728             break;
13729           case 0xd7:
13730               GETBYTE ();
13731               switch (op[2] & 0x00)
13732               {
13733                 case 0x00:
13734                   goto op_semantics_97;
13735                   break;
13736               }
13737             break;
13738           case 0xd8:
13739               GETBYTE ();
13740               switch (op[2] & 0x00)
13741               {
13742                 case 0x00:
13743                   goto op_semantics_97;
13744                   break;
13745               }
13746             break;
13747           case 0xd9:
13748               GETBYTE ();
13749               switch (op[2] & 0x00)
13750               {
13751                 case 0x00:
13752                   goto op_semantics_97;
13753                   break;
13754               }
13755             break;
13756           case 0xda:
13757               GETBYTE ();
13758               switch (op[2] & 0x00)
13759               {
13760                 case 0x00:
13761                   goto op_semantics_97;
13762                   break;
13763               }
13764             break;
13765           case 0xdb:
13766               GETBYTE ();
13767               switch (op[2] & 0x00)
13768               {
13769                 case 0x00:
13770                   goto op_semantics_97;
13771                   break;
13772               }
13773             break;
13774           case 0xdc:
13775               GETBYTE ();
13776               switch (op[2] & 0x00)
13777               {
13778                 case 0x00:
13779                   goto op_semantics_97;
13780                   break;
13781               }
13782             break;
13783           case 0xdd:
13784               GETBYTE ();
13785               switch (op[2] & 0x00)
13786               {
13787                 case 0x00:
13788                   goto op_semantics_97;
13789                   break;
13790               }
13791             break;
13792           case 0xde:
13793               GETBYTE ();
13794               switch (op[2] & 0x00)
13795               {
13796                 case 0x00:
13797                   goto op_semantics_97;
13798                   break;
13799               }
13800             break;
13801           case 0xdf:
13802               GETBYTE ();
13803               switch (op[2] & 0x00)
13804               {
13805                 case 0x00:
13806                   goto op_semantics_97;
13807                   break;
13808               }
13809             break;
13810           case 0xe0:
13811               GETBYTE ();
13812               switch (op[2] & 0x00)
13813               {
13814                 case 0x00:
13815                   goto op_semantics_97;
13816                   break;
13817               }
13818             break;
13819           case 0xe1:
13820               GETBYTE ();
13821               switch (op[2] & 0x00)
13822               {
13823                 case 0x00:
13824                   goto op_semantics_97;
13825                   break;
13826               }
13827             break;
13828           case 0xe2:
13829               GETBYTE ();
13830               switch (op[2] & 0x00)
13831               {
13832                 case 0x00:
13833                   goto op_semantics_97;
13834                   break;
13835               }
13836             break;
13837           case 0xe3:
13838               GETBYTE ();
13839               switch (op[2] & 0x00)
13840               {
13841                 case 0x00:
13842                   goto op_semantics_97;
13843                   break;
13844               }
13845             break;
13846           case 0xe4:
13847               GETBYTE ();
13848               switch (op[2] & 0x00)
13849               {
13850                 case 0x00:
13851                   goto op_semantics_97;
13852                   break;
13853               }
13854             break;
13855           case 0xe5:
13856               GETBYTE ();
13857               switch (op[2] & 0x00)
13858               {
13859                 case 0x00:
13860                   goto op_semantics_97;
13861                   break;
13862               }
13863             break;
13864           case 0xe6:
13865               GETBYTE ();
13866               switch (op[2] & 0x00)
13867               {
13868                 case 0x00:
13869                   goto op_semantics_97;
13870                   break;
13871               }
13872             break;
13873           case 0xe7:
13874               GETBYTE ();
13875               switch (op[2] & 0x00)
13876               {
13877                 case 0x00:
13878                   goto op_semantics_97;
13879                   break;
13880               }
13881             break;
13882           case 0xe8:
13883               GETBYTE ();
13884               switch (op[2] & 0x00)
13885               {
13886                 case 0x00:
13887                   goto op_semantics_97;
13888                   break;
13889               }
13890             break;
13891           case 0xe9:
13892               GETBYTE ();
13893               switch (op[2] & 0x00)
13894               {
13895                 case 0x00:
13896                   goto op_semantics_97;
13897                   break;
13898               }
13899             break;
13900           case 0xea:
13901               GETBYTE ();
13902               switch (op[2] & 0x00)
13903               {
13904                 case 0x00:
13905                   goto op_semantics_97;
13906                   break;
13907               }
13908             break;
13909           case 0xeb:
13910               GETBYTE ();
13911               switch (op[2] & 0x00)
13912               {
13913                 case 0x00:
13914                   goto op_semantics_97;
13915                   break;
13916               }
13917             break;
13918           case 0xec:
13919               GETBYTE ();
13920               switch (op[2] & 0x00)
13921               {
13922                 case 0x00:
13923                   goto op_semantics_97;
13924                   break;
13925               }
13926             break;
13927           case 0xed:
13928               GETBYTE ();
13929               switch (op[2] & 0x00)
13930               {
13931                 case 0x00:
13932                   goto op_semantics_97;
13933                   break;
13934               }
13935             break;
13936           case 0xee:
13937               GETBYTE ();
13938               switch (op[2] & 0x00)
13939               {
13940                 case 0x00:
13941                   goto op_semantics_97;
13942                   break;
13943               }
13944             break;
13945           case 0xef:
13946               GETBYTE ();
13947               switch (op[2] & 0x00)
13948               {
13949                 case 0x00:
13950                   goto op_semantics_97;
13951                   break;
13952               }
13953             break;
13954           default: UNSUPPORTED(); break;
13955         }
13956       break;
13957     case 0xff:
13958         GETBYTE ();
13959         switch (op[1] & 0xff)
13960         {
13961           case 0x00:
13962               GETBYTE ();
13963               switch (op[2] & 0x00)
13964               {
13965                 case 0x00:
13966                   op_semantics_98:
13967                     {
13968                       /** 1111 1111 0000 rdst srca srcb sub     %2, %1, %0 */
13969 #line 524 "/work/sources/gcc/current/opcodes/rx-decode.opc"
13970                       int rdst AU = op[1] & 0x0f;
13971 #line 524 "/work/sources/gcc/current/opcodes/rx-decode.opc"
13972                       int srca AU = (op[2] >> 4) & 0x0f;
13973 #line 524 "/work/sources/gcc/current/opcodes/rx-decode.opc"
13974                       int srcb AU = op[2] & 0x0f;
13975                       if (trace)
13976                         {
13977                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13978                                  "/** 1111 1111 0000 rdst srca srcb     sub     %2, %1, %0 */",
13979                                  op[0], op[1], op[2]);
13980                           printf ("  rdst = 0x%x,", rdst);
13981                           printf ("  srca = 0x%x,", srca);
13982                           printf ("  srcb = 0x%x\n", srcb);
13983                         }
13984                       SYNTAX("sub       %2, %1, %0");
13985 #line 525 "/work/sources/gcc/current/opcodes/rx-decode.opc"
13986                       ID(sub); DR(rdst); SR(srcb); S2R(srca); F("OSZC");
13987
13988                     /*----------------------------------------------------------------------*/
13989                     /* SBB                                                                      */
13990
13991                     }
13992                   break;
13993               }
13994             break;
13995           case 0x01:
13996               GETBYTE ();
13997               switch (op[2] & 0x00)
13998               {
13999                 case 0x00:
14000                   goto op_semantics_98;
14001                   break;
14002               }
14003             break;
14004           case 0x02:
14005               GETBYTE ();
14006               switch (op[2] & 0x00)
14007               {
14008                 case 0x00:
14009                   goto op_semantics_98;
14010                   break;
14011               }
14012             break;
14013           case 0x03:
14014               GETBYTE ();
14015               switch (op[2] & 0x00)
14016               {
14017                 case 0x00:
14018                   goto op_semantics_98;
14019                   break;
14020               }
14021             break;
14022           case 0x04:
14023               GETBYTE ();
14024               switch (op[2] & 0x00)
14025               {
14026                 case 0x00:
14027                   goto op_semantics_98;
14028                   break;
14029               }
14030             break;
14031           case 0x05:
14032               GETBYTE ();
14033               switch (op[2] & 0x00)
14034               {
14035                 case 0x00:
14036                   goto op_semantics_98;
14037                   break;
14038               }
14039             break;
14040           case 0x06:
14041               GETBYTE ();
14042               switch (op[2] & 0x00)
14043               {
14044                 case 0x00:
14045                   goto op_semantics_98;
14046                   break;
14047               }
14048             break;
14049           case 0x07:
14050               GETBYTE ();
14051               switch (op[2] & 0x00)
14052               {
14053                 case 0x00:
14054                   goto op_semantics_98;
14055                   break;
14056               }
14057             break;
14058           case 0x08:
14059               GETBYTE ();
14060               switch (op[2] & 0x00)
14061               {
14062                 case 0x00:
14063                   goto op_semantics_98;
14064                   break;
14065               }
14066             break;
14067           case 0x09:
14068               GETBYTE ();
14069               switch (op[2] & 0x00)
14070               {
14071                 case 0x00:
14072                   goto op_semantics_98;
14073                   break;
14074               }
14075             break;
14076           case 0x0a:
14077               GETBYTE ();
14078               switch (op[2] & 0x00)
14079               {
14080                 case 0x00:
14081                   goto op_semantics_98;
14082                   break;
14083               }
14084             break;
14085           case 0x0b:
14086               GETBYTE ();
14087               switch (op[2] & 0x00)
14088               {
14089                 case 0x00:
14090                   goto op_semantics_98;
14091                   break;
14092               }
14093             break;
14094           case 0x0c:
14095               GETBYTE ();
14096               switch (op[2] & 0x00)
14097               {
14098                 case 0x00:
14099                   goto op_semantics_98;
14100                   break;
14101               }
14102             break;
14103           case 0x0d:
14104               GETBYTE ();
14105               switch (op[2] & 0x00)
14106               {
14107                 case 0x00:
14108                   goto op_semantics_98;
14109                   break;
14110               }
14111             break;
14112           case 0x0e:
14113               GETBYTE ();
14114               switch (op[2] & 0x00)
14115               {
14116                 case 0x00:
14117                   goto op_semantics_98;
14118                   break;
14119               }
14120             break;
14121           case 0x0f:
14122               GETBYTE ();
14123               switch (op[2] & 0x00)
14124               {
14125                 case 0x00:
14126                   goto op_semantics_98;
14127                   break;
14128               }
14129             break;
14130           case 0x20:
14131               GETBYTE ();
14132               switch (op[2] & 0x00)
14133               {
14134                 case 0x00:
14135                   op_semantics_99:
14136                     {
14137                       /** 1111 1111 0010 rdst srca srcb add     %2, %1, %0 */
14138 #line 491 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14139                       int rdst AU = op[1] & 0x0f;
14140 #line 491 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14141                       int srca AU = (op[2] >> 4) & 0x0f;
14142 #line 491 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14143                       int srcb AU = op[2] & 0x0f;
14144                       if (trace)
14145                         {
14146                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14147                                  "/** 1111 1111 0010 rdst srca srcb     add     %2, %1, %0 */",
14148                                  op[0], op[1], op[2]);
14149                           printf ("  rdst = 0x%x,", rdst);
14150                           printf ("  srca = 0x%x,", srca);
14151                           printf ("  srcb = 0x%x\n", srcb);
14152                         }
14153                       SYNTAX("add       %2, %1, %0");
14154 #line 492 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14155                       ID(add); DR(rdst); SR(srcb); S2R(srca); F("OSZC");
14156
14157                     /*----------------------------------------------------------------------*/
14158                     /* CMP                                                                      */
14159
14160                     }
14161                   break;
14162               }
14163             break;
14164           case 0x21:
14165               GETBYTE ();
14166               switch (op[2] & 0x00)
14167               {
14168                 case 0x00:
14169                   goto op_semantics_99;
14170                   break;
14171               }
14172             break;
14173           case 0x22:
14174               GETBYTE ();
14175               switch (op[2] & 0x00)
14176               {
14177                 case 0x00:
14178                   goto op_semantics_99;
14179                   break;
14180               }
14181             break;
14182           case 0x23:
14183               GETBYTE ();
14184               switch (op[2] & 0x00)
14185               {
14186                 case 0x00:
14187                   goto op_semantics_99;
14188                   break;
14189               }
14190             break;
14191           case 0x24:
14192               GETBYTE ();
14193               switch (op[2] & 0x00)
14194               {
14195                 case 0x00:
14196                   goto op_semantics_99;
14197                   break;
14198               }
14199             break;
14200           case 0x25:
14201               GETBYTE ();
14202               switch (op[2] & 0x00)
14203               {
14204                 case 0x00:
14205                   goto op_semantics_99;
14206                   break;
14207               }
14208             break;
14209           case 0x26:
14210               GETBYTE ();
14211               switch (op[2] & 0x00)
14212               {
14213                 case 0x00:
14214                   goto op_semantics_99;
14215                   break;
14216               }
14217             break;
14218           case 0x27:
14219               GETBYTE ();
14220               switch (op[2] & 0x00)
14221               {
14222                 case 0x00:
14223                   goto op_semantics_99;
14224                   break;
14225               }
14226             break;
14227           case 0x28:
14228               GETBYTE ();
14229               switch (op[2] & 0x00)
14230               {
14231                 case 0x00:
14232                   goto op_semantics_99;
14233                   break;
14234               }
14235             break;
14236           case 0x29:
14237               GETBYTE ();
14238               switch (op[2] & 0x00)
14239               {
14240                 case 0x00:
14241                   goto op_semantics_99;
14242                   break;
14243               }
14244             break;
14245           case 0x2a:
14246               GETBYTE ();
14247               switch (op[2] & 0x00)
14248               {
14249                 case 0x00:
14250                   goto op_semantics_99;
14251                   break;
14252               }
14253             break;
14254           case 0x2b:
14255               GETBYTE ();
14256               switch (op[2] & 0x00)
14257               {
14258                 case 0x00:
14259                   goto op_semantics_99;
14260                   break;
14261               }
14262             break;
14263           case 0x2c:
14264               GETBYTE ();
14265               switch (op[2] & 0x00)
14266               {
14267                 case 0x00:
14268                   goto op_semantics_99;
14269                   break;
14270               }
14271             break;
14272           case 0x2d:
14273               GETBYTE ();
14274               switch (op[2] & 0x00)
14275               {
14276                 case 0x00:
14277                   goto op_semantics_99;
14278                   break;
14279               }
14280             break;
14281           case 0x2e:
14282               GETBYTE ();
14283               switch (op[2] & 0x00)
14284               {
14285                 case 0x00:
14286                   goto op_semantics_99;
14287                   break;
14288               }
14289             break;
14290           case 0x2f:
14291               GETBYTE ();
14292               switch (op[2] & 0x00)
14293               {
14294                 case 0x00:
14295                   goto op_semantics_99;
14296                   break;
14297               }
14298             break;
14299           case 0x30:
14300               GETBYTE ();
14301               switch (op[2] & 0x00)
14302               {
14303                 case 0x00:
14304                   op_semantics_100:
14305                     {
14306                       /** 1111 1111 0011 rdst srca srcb mul     %2, %1, %0 */
14307 #line 585 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14308                       int rdst AU = op[1] & 0x0f;
14309 #line 585 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14310                       int srca AU = (op[2] >> 4) & 0x0f;
14311 #line 585 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14312                       int srcb AU = op[2] & 0x0f;
14313                       if (trace)
14314                         {
14315                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14316                                  "/** 1111 1111 0011 rdst srca srcb     mul     %2, %1, %0 */",
14317                                  op[0], op[1], op[2]);
14318                           printf ("  rdst = 0x%x,", rdst);
14319                           printf ("  srca = 0x%x,", srca);
14320                           printf ("  srcb = 0x%x\n", srcb);
14321                         }
14322                       SYNTAX("mul       %2, %1, %0");
14323 #line 586 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14324                       ID(mul); DR(rdst); SR(srcb); S2R(srca); F("O---");
14325
14326                     /*----------------------------------------------------------------------*/
14327                     /* EMUL                                                                     */
14328
14329                     }
14330                   break;
14331               }
14332             break;
14333           case 0x31:
14334               GETBYTE ();
14335               switch (op[2] & 0x00)
14336               {
14337                 case 0x00:
14338                   goto op_semantics_100;
14339                   break;
14340               }
14341             break;
14342           case 0x32:
14343               GETBYTE ();
14344               switch (op[2] & 0x00)
14345               {
14346                 case 0x00:
14347                   goto op_semantics_100;
14348                   break;
14349               }
14350             break;
14351           case 0x33:
14352               GETBYTE ();
14353               switch (op[2] & 0x00)
14354               {
14355                 case 0x00:
14356                   goto op_semantics_100;
14357                   break;
14358               }
14359             break;
14360           case 0x34:
14361               GETBYTE ();
14362               switch (op[2] & 0x00)
14363               {
14364                 case 0x00:
14365                   goto op_semantics_100;
14366                   break;
14367               }
14368             break;
14369           case 0x35:
14370               GETBYTE ();
14371               switch (op[2] & 0x00)
14372               {
14373                 case 0x00:
14374                   goto op_semantics_100;
14375                   break;
14376               }
14377             break;
14378           case 0x36:
14379               GETBYTE ();
14380               switch (op[2] & 0x00)
14381               {
14382                 case 0x00:
14383                   goto op_semantics_100;
14384                   break;
14385               }
14386             break;
14387           case 0x37:
14388               GETBYTE ();
14389               switch (op[2] & 0x00)
14390               {
14391                 case 0x00:
14392                   goto op_semantics_100;
14393                   break;
14394               }
14395             break;
14396           case 0x38:
14397               GETBYTE ();
14398               switch (op[2] & 0x00)
14399               {
14400                 case 0x00:
14401                   goto op_semantics_100;
14402                   break;
14403               }
14404             break;
14405           case 0x39:
14406               GETBYTE ();
14407               switch (op[2] & 0x00)
14408               {
14409                 case 0x00:
14410                   goto op_semantics_100;
14411                   break;
14412               }
14413             break;
14414           case 0x3a:
14415               GETBYTE ();
14416               switch (op[2] & 0x00)
14417               {
14418                 case 0x00:
14419                   goto op_semantics_100;
14420                   break;
14421               }
14422             break;
14423           case 0x3b:
14424               GETBYTE ();
14425               switch (op[2] & 0x00)
14426               {
14427                 case 0x00:
14428                   goto op_semantics_100;
14429                   break;
14430               }
14431             break;
14432           case 0x3c:
14433               GETBYTE ();
14434               switch (op[2] & 0x00)
14435               {
14436                 case 0x00:
14437                   goto op_semantics_100;
14438                   break;
14439               }
14440             break;
14441           case 0x3d:
14442               GETBYTE ();
14443               switch (op[2] & 0x00)
14444               {
14445                 case 0x00:
14446                   goto op_semantics_100;
14447                   break;
14448               }
14449             break;
14450           case 0x3e:
14451               GETBYTE ();
14452               switch (op[2] & 0x00)
14453               {
14454                 case 0x00:
14455                   goto op_semantics_100;
14456                   break;
14457               }
14458             break;
14459           case 0x3f:
14460               GETBYTE ();
14461               switch (op[2] & 0x00)
14462               {
14463                 case 0x00:
14464                   goto op_semantics_100;
14465                   break;
14466               }
14467             break;
14468           case 0x40:
14469               GETBYTE ();
14470               switch (op[2] & 0x00)
14471               {
14472                 case 0x00:
14473                   op_semantics_101:
14474                     {
14475                       /** 1111 1111 0100 rdst srca srcb and     %2, %1, %0 */
14476 #line 401 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14477                       int rdst AU = op[1] & 0x0f;
14478 #line 401 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14479                       int srca AU = (op[2] >> 4) & 0x0f;
14480 #line 401 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14481                       int srcb AU = op[2] & 0x0f;
14482                       if (trace)
14483                         {
14484                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14485                                  "/** 1111 1111 0100 rdst srca srcb     and     %2, %1, %0 */",
14486                                  op[0], op[1], op[2]);
14487                           printf ("  rdst = 0x%x,", rdst);
14488                           printf ("  srca = 0x%x,", srca);
14489                           printf ("  srcb = 0x%x\n", srcb);
14490                         }
14491                       SYNTAX("and       %2, %1, %0");
14492 #line 402 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14493                       ID(and); DR(rdst); SR(srcb); S2R(srca); F("-SZ-");
14494
14495                     /*----------------------------------------------------------------------*/
14496                     /* OR                                                                       */
14497
14498                     }
14499                   break;
14500               }
14501             break;
14502           case 0x41:
14503               GETBYTE ();
14504               switch (op[2] & 0x00)
14505               {
14506                 case 0x00:
14507                   goto op_semantics_101;
14508                   break;
14509               }
14510             break;
14511           case 0x42:
14512               GETBYTE ();
14513               switch (op[2] & 0x00)
14514               {
14515                 case 0x00:
14516                   goto op_semantics_101;
14517                   break;
14518               }
14519             break;
14520           case 0x43:
14521               GETBYTE ();
14522               switch (op[2] & 0x00)
14523               {
14524                 case 0x00:
14525                   goto op_semantics_101;
14526                   break;
14527               }
14528             break;
14529           case 0x44:
14530               GETBYTE ();
14531               switch (op[2] & 0x00)
14532               {
14533                 case 0x00:
14534                   goto op_semantics_101;
14535                   break;
14536               }
14537             break;
14538           case 0x45:
14539               GETBYTE ();
14540               switch (op[2] & 0x00)
14541               {
14542                 case 0x00:
14543                   goto op_semantics_101;
14544                   break;
14545               }
14546             break;
14547           case 0x46:
14548               GETBYTE ();
14549               switch (op[2] & 0x00)
14550               {
14551                 case 0x00:
14552                   goto op_semantics_101;
14553                   break;
14554               }
14555             break;
14556           case 0x47:
14557               GETBYTE ();
14558               switch (op[2] & 0x00)
14559               {
14560                 case 0x00:
14561                   goto op_semantics_101;
14562                   break;
14563               }
14564             break;
14565           case 0x48:
14566               GETBYTE ();
14567               switch (op[2] & 0x00)
14568               {
14569                 case 0x00:
14570                   goto op_semantics_101;
14571                   break;
14572               }
14573             break;
14574           case 0x49:
14575               GETBYTE ();
14576               switch (op[2] & 0x00)
14577               {
14578                 case 0x00:
14579                   goto op_semantics_101;
14580                   break;
14581               }
14582             break;
14583           case 0x4a:
14584               GETBYTE ();
14585               switch (op[2] & 0x00)
14586               {
14587                 case 0x00:
14588                   goto op_semantics_101;
14589                   break;
14590               }
14591             break;
14592           case 0x4b:
14593               GETBYTE ();
14594               switch (op[2] & 0x00)
14595               {
14596                 case 0x00:
14597                   goto op_semantics_101;
14598                   break;
14599               }
14600             break;
14601           case 0x4c:
14602               GETBYTE ();
14603               switch (op[2] & 0x00)
14604               {
14605                 case 0x00:
14606                   goto op_semantics_101;
14607                   break;
14608               }
14609             break;
14610           case 0x4d:
14611               GETBYTE ();
14612               switch (op[2] & 0x00)
14613               {
14614                 case 0x00:
14615                   goto op_semantics_101;
14616                   break;
14617               }
14618             break;
14619           case 0x4e:
14620               GETBYTE ();
14621               switch (op[2] & 0x00)
14622               {
14623                 case 0x00:
14624                   goto op_semantics_101;
14625                   break;
14626               }
14627             break;
14628           case 0x4f:
14629               GETBYTE ();
14630               switch (op[2] & 0x00)
14631               {
14632                 case 0x00:
14633                   goto op_semantics_101;
14634                   break;
14635               }
14636             break;
14637           case 0x50:
14638               GETBYTE ();
14639               switch (op[2] & 0x00)
14640               {
14641                 case 0x00:
14642                   op_semantics_102:
14643                     {
14644                       /** 1111 1111 0101 rdst srca srcb or      %2, %1, %0 */
14645 #line 419 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14646                       int rdst AU = op[1] & 0x0f;
14647 #line 419 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14648                       int srca AU = (op[2] >> 4) & 0x0f;
14649 #line 419 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14650                       int srcb AU = op[2] & 0x0f;
14651                       if (trace)
14652                         {
14653                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14654                                  "/** 1111 1111 0101 rdst srca srcb     or      %2, %1, %0 */",
14655                                  op[0], op[1], op[2]);
14656                           printf ("  rdst = 0x%x,", rdst);
14657                           printf ("  srca = 0x%x,", srca);
14658                           printf ("  srcb = 0x%x\n", srcb);
14659                         }
14660                       SYNTAX("or        %2, %1, %0");
14661 #line 420 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14662                       ID(or); DR(rdst); SR(srcb); S2R(srca); F("-SZ-");
14663
14664                     /*----------------------------------------------------------------------*/
14665                     /* XOR                                                                      */
14666
14667                     }
14668                   break;
14669               }
14670             break;
14671           case 0x51:
14672               GETBYTE ();
14673               switch (op[2] & 0x00)
14674               {
14675                 case 0x00:
14676                   goto op_semantics_102;
14677                   break;
14678               }
14679             break;
14680           case 0x52:
14681               GETBYTE ();
14682               switch (op[2] & 0x00)
14683               {
14684                 case 0x00:
14685                   goto op_semantics_102;
14686                   break;
14687               }
14688             break;
14689           case 0x53:
14690               GETBYTE ();
14691               switch (op[2] & 0x00)
14692               {
14693                 case 0x00:
14694                   goto op_semantics_102;
14695                   break;
14696               }
14697             break;
14698           case 0x54:
14699               GETBYTE ();
14700               switch (op[2] & 0x00)
14701               {
14702                 case 0x00:
14703                   goto op_semantics_102;
14704                   break;
14705               }
14706             break;
14707           case 0x55:
14708               GETBYTE ();
14709               switch (op[2] & 0x00)
14710               {
14711                 case 0x00:
14712                   goto op_semantics_102;
14713                   break;
14714               }
14715             break;
14716           case 0x56:
14717               GETBYTE ();
14718               switch (op[2] & 0x00)
14719               {
14720                 case 0x00:
14721                   goto op_semantics_102;
14722                   break;
14723               }
14724             break;
14725           case 0x57:
14726               GETBYTE ();
14727               switch (op[2] & 0x00)
14728               {
14729                 case 0x00:
14730                   goto op_semantics_102;
14731                   break;
14732               }
14733             break;
14734           case 0x58:
14735               GETBYTE ();
14736               switch (op[2] & 0x00)
14737               {
14738                 case 0x00:
14739                   goto op_semantics_102;
14740                   break;
14741               }
14742             break;
14743           case 0x59:
14744               GETBYTE ();
14745               switch (op[2] & 0x00)
14746               {
14747                 case 0x00:
14748                   goto op_semantics_102;
14749                   break;
14750               }
14751             break;
14752           case 0x5a:
14753               GETBYTE ();
14754               switch (op[2] & 0x00)
14755               {
14756                 case 0x00:
14757                   goto op_semantics_102;
14758                   break;
14759               }
14760             break;
14761           case 0x5b:
14762               GETBYTE ();
14763               switch (op[2] & 0x00)
14764               {
14765                 case 0x00:
14766                   goto op_semantics_102;
14767                   break;
14768               }
14769             break;
14770           case 0x5c:
14771               GETBYTE ();
14772               switch (op[2] & 0x00)
14773               {
14774                 case 0x00:
14775                   goto op_semantics_102;
14776                   break;
14777               }
14778             break;
14779           case 0x5d:
14780               GETBYTE ();
14781               switch (op[2] & 0x00)
14782               {
14783                 case 0x00:
14784                   goto op_semantics_102;
14785                   break;
14786               }
14787             break;
14788           case 0x5e:
14789               GETBYTE ();
14790               switch (op[2] & 0x00)
14791               {
14792                 case 0x00:
14793                   goto op_semantics_102;
14794                   break;
14795               }
14796             break;
14797           case 0x5f:
14798               GETBYTE ();
14799               switch (op[2] & 0x00)
14800               {
14801                 case 0x00:
14802                   goto op_semantics_102;
14803                   break;
14804               }
14805             break;
14806           default: UNSUPPORTED(); break;
14807         }
14808       break;
14809     default: UNSUPPORTED(); break;
14810   }
14811 #line 975 "/work/sources/gcc/current/opcodes/rx-decode.opc"
14812
14813   return rx->n_bytes;
14814 }