/* DO NOT EDIT!  -*- buffer-read-only: t -*- vi:set ro:  */

#line 1 "rx-decode.opc"

/* -*- c -*- */

/* Copyright (C) 2012-2023 Free Software Foundation, Inc.

   Contributed by Red Hat.

   Written by DJ Delorie.

   This file is part of the GNU opcodes library.

   This library is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3, or (at your option)

   any later version.

   It is distributed in the hope that it will be useful, but WITHOUT

   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY

   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public

   License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,

   MA 02110-1301, USA.  */

#include "sysdep.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "ansidecl.h"

#include "opcode/rx.h"

#include "libiberty.h"

#define RX_OPCODE_BIG_ENDIAN 0

typedef struct

{

  RX_Opcode_Decoded * rx;

  int (* getbyte)(void *);

  void * ptr;

  unsigned char * op;

} LocalData;

static int trace = 0;

#define BSIZE 0

#define WSIZE 1

#define LSIZE 2

#define DSIZE 3

/* These are for when the upper bits are "don't care" or "undefined".  */

static int bwl[4] =

{

  RX_Byte,

  RX_Word,

  RX_Long,

  RX_Bad_Size /* Bogus instructions can have a size field set to 3.  */

};

static int sbwl[4] =

{

  RX_SByte,

  RX_SWord,

  RX_Long,

  RX_Bad_Size /* Bogus instructions can have a size field set to 3.  */

};

static int ubw[4] =

{

  RX_UByte,

  RX_UWord,

  RX_Bad_Size,/* Bogus instructions can have a size field set to 2.  */

  RX_Bad_Size /* Bogus instructions can have a size field set to 3.  */

};

static int memex[4] =

{

  RX_SByte,

  RX_SWord,

  RX_Long,

  RX_UWord

};

static int _ld[2] =

{

  RX_Long,

  RX_Double

};

#define ID(x) rx->id = RXO_##x

#define OP(n,t,r,a) (rx->op[n].type = t, \

         rx->op[n].reg = r,      \

         rx->op[n].addend = a )

#define OPs(n,t,r,a,s) (OP (n,t,r,a), \

      rx->op[n].size = s )

/* This is for the BWL and BW bitfields.  */

static int SCALE[] = { 1, 2, 4, 0 };

/* This is for the prefix size enum.  */

static int PSCALE[] = { 4, 1, 1, 1, 2, 2, 2, 3, 4, 8 };

#define GET_SCALE(_indx)  ((unsigned)(_indx) < ARRAY_SIZE (SCALE) ? SCALE[(_indx)] : 0)

#define GET_PSCALE(_indx) ((unsigned)(_indx) < ARRAY_SIZE (PSCALE) ? PSCALE[(_indx)] : 0)

static int flagmap[] = {0, 1, 2, 3, 0, 0, 0, 0,

           16, 17, 0, 0, 0, 0, 0, 0 };

static int dsp3map[] = { 8, 9, 10, 3, 4, 5, 6, 7 };

/*

 *C a constant (immediate) c

 *R A register

 *I Register indirect, no offset

 *Is  Register indirect, with offset

 *D standard displacement: type (r,[r],dsp8,dsp16 code), register, BWL code

 *P standard displacement: type (r,[r]), reg, assumes UByte

 *Pm  memex displacement: type (r,[r]), reg, memex code

 *cc  condition code.  */

#define DC(c)       OP (0, RX_Operand_Immediate, 0, c)

#define DR(r)       OP (0, RX_Operand_Register,  r, 0)

#define DI(r,a)     OP (0, RX_Operand_Indirect,  r, a)

#define DIs(r,a,s)  OP (0, RX_Operand_Indirect,  r, (a) * GET_SCALE (s))

#define DD(t,r,s)   rx_disp (0, t, r, bwl[s], ld);

#define DF(r)       OP (0, RX_Operand_Flag,  flagmap[r], 0)

#define DCR(r)      OP (0, RX_Operand_DoubleCReg, r, 0)

#define DDR(r)      OP (0, RX_Operand_DoubleReg,  r, 0)

#define DDRH(r)     OP (0, RX_Operand_DoubleRegH,  r, 0)

#define DDRL(r)     OP (0, RX_Operand_DoubleRegL,  r, 0)

#define DCND(r)     OP (0, RX_Operand_DoubleCond, r, 0)

#define SC(i)       OP (1, RX_Operand_Immediate, 0, i)

#define SR(r)       OP (1, RX_Operand_Register,  r, 0)

#define SRR(r)      OP (1, RX_Operand_TwoReg,  r, 0)

#define SI(r,a)     OP (1, RX_Operand_Indirect,  r, a)

#define SIs(r,a,s)  OP (1, RX_Operand_Indirect,  r, (a) * GET_SCALE (s))

#define SD(t,r,s)   rx_disp (1, t, r, bwl[s], ld);

#define SP(t,r)     rx_disp (1, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 1);

#define SPm(t,r,m)  rx_disp (1, t, r, memex[m], ld); rx->op[1].size = memex[m];

#define Scc(cc)     OP (1, RX_Operand_Condition,  cc, 0)

#define SCR(r)      OP (1, RX_Operand_DoubleCReg, r, 0)

#define SDR(r)      OP (1, RX_Operand_DoubleReg,  r, 0)

#define SDRH(r)      OP (1, RX_Operand_DoubleRegH,  r, 0)

#define SDRL(r)      OP (1, RX_Operand_DoubleRegL,  r, 0)

#define S2C(i)      OP (2, RX_Operand_Immediate, 0, i)

#define S2R(r)      OP (2, RX_Operand_Register,  r, 0)

#define S2I(r,a)    OP (2, RX_Operand_Indirect,  r, a)

#define S2Is(r,a,s) OP (2, RX_Operand_Indirect,  r, (a) * GET_SCALE (s))

#define S2D(t,r,s)  rx_disp (2, t, r, bwl[s], ld);

#define S2P(t,r)    rx_disp (2, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 2);

#define S2Pm(t,r,m) rx_disp (2, t, r, memex[m], ld); rx->op[2].size = memex[m];

#define S2cc(cc)    OP (2, RX_Operand_Condition,  cc, 0)

#define S2DR(r)     OP (2, RX_Operand_DoubleReg,  r, 0)

#define S2CR(r)     OP (2, RX_Operand_DoubleCReg, r, 0)

#define SDD(t,r,s)  rx_disp (1, t, r, bwl, ld);

#define BWL(sz)     rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = bwl[sz]

#define sBWL(sz)    rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = sbwl[sz]

#define uBW(sz)     rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = ubw[sz]

#define P(t, n)     rx->op[n].size = (t!=3) ? RX_UByte : RX_Long;

#define DL(sz)      rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = _ld[sz]

#define F(f) store_flags(rx, f)

#define AU ATTRIBUTE_UNUSED

#define GETBYTE() (ld->op [ld->rx->n_bytes++] = ld->getbyte (ld->ptr))

#define SYNTAX(x) rx->syntax = x

#define UNSUPPORTED() \

  rx->syntax = "*unknown*"

#define IMM(sf)   immediate (sf, 0, ld)

#define IMMex(sf) immediate (sf, 1, ld)

static int

immediate (int sfield, int ex, LocalData * ld)

{

  unsigned long i = 0, j;

  switch (sfield)

    {

#define B ((unsigned long) GETBYTE())

    case 0:

#if RX_OPCODE_BIG_ENDIAN

      i  = B;

      if (ex && (i & 0x80))

  i -= 0x100;

      i <<= 24;

      i |= B << 16;

      i |= B << 8;

      i |= B;

#else

      i = B;

      i |= B << 8;

      i |= B << 16;

      j = B;

      if (ex && (j & 0x80))

  j -= 0x100;

      i |= j << 24;

#endif

      break;

    case 3:

#if RX_OPCODE_BIG_ENDIAN

      i  = B << 16;

      i |= B << 8;

      i |= B;

#else

      i  = B;

      i |= B << 8;

      i |= B << 16;

#endif

      if (ex && (i & 0x800000))

  i -= 0x1000000;

      break;

    case 2:

#if RX_OPCODE_BIG_ENDIAN

      i |= B << 8;

      i |= B;

#else

      i |= B;

      i |= B << 8;

#endif

      if (ex && (i & 0x8000))

  i -= 0x10000;

      break;

    case 1:

      i |= B;

      if (ex && (i & 0x80))

  i -= 0x100;

      break;

    default:

      abort();

    }

  return i;

}

static void

rx_disp (int n, int type, int reg, unsigned int size, LocalData * ld)

{

  int disp;

  ld->rx->op[n].reg = reg;

  switch (type)

    {

    case 3:

      ld->rx->op[n].type = RX_Operand_Register;

      break;

    case 0:

      ld->rx->op[n].type = RX_Operand_Zero_Indirect;

      ld->rx->op[n].addend = 0;

      break;

    case 1:

      ld->rx->op[n].type = RX_Operand_Indirect;

      disp = GETBYTE ();

      ld->rx->op[n].addend = disp * GET_PSCALE (size);

      break;

    case 2:

      ld->rx->op[n].type = RX_Operand_Indirect;

      disp = GETBYTE ();

#if RX_OPCODE_BIG_ENDIAN

      disp = disp * 256 + GETBYTE ();

#else

      disp = disp + GETBYTE () * 256;

#endif

      ld->rx->op[n].addend = disp * GET_PSCALE (size);

      break;

    default:

      abort ();

    }

}

#define xO 8

#define xS 4

#define xZ 2

#define xC 1

#define F_____

#define F___ZC rx->flags_0 = rx->flags_s = xZ|xC;

#define F__SZ_ rx->flags_0 = rx->flags_s = xS|xZ;

#define F__SZC rx->flags_0 = rx->flags_s = xS|xZ|xC;

#define F_0SZC rx->flags_0 = xO|xS|xZ|xC; rx->flags_s = xS|xZ|xC;

#define F_O___ rx->flags_0 = rx->flags_s = xO;

#define F_OS__ rx->flags_0 = rx->flags_s = xO|xS;

#define F_OSZ_ rx->flags_0 = rx->flags_s = xO|xS|xZ;

#define F_OSZC rx->flags_0 = rx->flags_s = xO|xS|xZ|xC;

int

rx_decode_opcode (unsigned long pc AU,

      RX_Opcode_Decoded * rx,

      int (* getbyte)(void *),

      void * ptr)

{

  LocalData lds, * ld = &lds;

  unsigned char op[20] = {0};

  lds.rx = rx;

  lds.getbyte = getbyte;

  lds.ptr = ptr;

  lds.op = op;

  memset (rx, 0, sizeof (*rx));

  BWL(LSIZE);

/*----------------------------------------------------------------------*/

/* MOV                  */

  GETBYTE ();

  switch (op[0] & 0xff)

  {

    case 0x00:

        {

          /** 0000 0000     brk */

          if (trace)

            {

              printf ("\033[33m%s\033[0m  %02x\n",

                     "/** 0000 0000     brk */",

                     op[0]);

            }

          SYNTAX("brk");

#line 1050 "rx-decode.opc"

          ID(brk);

        }

      break;

    case 0x01:

        {

          /** 0000 0001     dbt */

          if (trace)

            {

              printf ("\033[33m%s\033[0m  %02x\n",

                     "/** 0000 0001     dbt */",

                     op[0]);

            }

          SYNTAX("dbt");

#line 1053 "rx-decode.opc"

          ID(dbt);

        }

      break;

    case 0x02:

        {

          /** 0000 0010     rts */

          if (trace)

            {

              printf ("\033[33m%s\033[0m  %02x\n",

                     "/** 0000 0010     rts */",

                     op[0]);

            }

          SYNTAX("rts");

#line 831 "rx-decode.opc"

          ID(rts);

        /*----------------------------------------------------------------------*/

        /* NOP                */

        }

      break;

    case 0x03:

        {

          /** 0000 0011     nop */

          if (trace)

            {

              printf ("\033[33m%s\033[0m  %02x\n",

                     "/** 0000 0011     nop */",

                     op[0]);

            }

          SYNTAX("nop");

#line 837 "rx-decode.opc"

          ID(nop);

        /*----------------------------------------------------------------------*/

        /* STRING FUNCTIONS             */

        }

      break;

    case 0x04:

        {

          /** 0000 0100     bra.a %a0 */

          if (trace)

            {

              printf ("\033[33m%s\033[0m  %02x\n",

                     "/** 0000 0100     bra.a %a0 */",

                     op[0]);

            }

          SYNTAX("bra.a %a0");

#line 809 "rx-decode.opc"

          ID(branch); DC(pc + IMMex(3));

        }

      break;

    case 0x05:

        {

          /** 0000 0101     bsr.a %a0 */

          if (trace)

            {

              printf ("\033[33m%s\033[0m  %02x\n",

                     "/** 0000 0101     bsr.a %a0 */",

                     op[0]);

            }

          SYNTAX("bsr.a %a0");

#line 825 "rx-decode.opc"

          ID(jsr); DC(pc + IMMex(3));

        }

      break;

    case 0x06:

        GETBYTE ();

        switch (op[1] & 0xff)

        {

          case 0x00:

              GETBYTE ();

              switch (op[2] & 0x00)

              {

                case 0x00:

                  op_semantics_1:

                    {

                      /** 0000 0110 mx00 00ss rsrc rdst     sub %2%S2, %1 */

#line 567 "rx-decode.opc"

                      int mx AU = (op[1] >> 6) & 0x03;

#line 567 "rx-decode.opc"

                      int ss AU = op[1] & 0x03;

#line 567 "rx-decode.opc"

                      int rsrc AU = (op[2] >> 4) & 0x0f;

#line 567 "rx-decode.opc"

                      int rdst AU = op[2] & 0x0f;

                      if (trace)

                        {

                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",

                                 "/** 0000 0110 mx00 00ss rsrc rdst     sub %2%S2, %1 */",

                                 op[0], op[1], op[2]);

                          printf ("  mx = 0x%x,", mx);

                          printf ("  ss = 0x%x,", ss);

                          printf ("  rsrc = 0x%x,", rsrc);

                          printf ("  rdst = 0x%x\n", rdst);

                        }

                      SYNTAX("sub %2%S2, %1");

#line 567 "rx-decode.opc"

                      ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F_OSZC;

                    }

                  break;

              }

            break;

          case 0x01:

              GETBYTE ();

              switch (op[2] & 0x00)

              {

                case 0x00:

                  goto op_semantics_1;

                  break;

              }

            break;

          case 0x02:

              GETBYTE ();

              switch (op[2] & 0x00)

              {

                case 0x00:

                  goto op_semantics_1;

                  break;

              }

            break;

          case 0x03:

              GETBYTE ();

              switch (op[2] & 0x00)

              {

                case 0x00:

                  goto op_semantics_1;

                  break;

              }

            break;

          case 0x04:

              GETBYTE ();

              switch (op[2] & 0x00)

              {

                case 0x00:

                  op_semantics_2:

                    {

                      /** 0000 0110 mx00 01ss rsrc rdst   cmp %2%S2, %1 */

#line 555 "rx-decode.opc"

                      int mx AU = (op[1] >> 6) & 0x03;

#line 555 "rx-decode.opc"

                      int ss AU = op[1] & 0x03;

#line 555 "rx-decode.opc"

                      int rsrc AU = (op[2] >> 4) & 0x0f;

#line 555 "rx-decode.opc"

                      int rdst AU = op[2] & 0x0f;

                      if (trace)

                        {

                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",

                                 "/** 0000 0110 mx00 01ss rsrc rdst   cmp %2%S2, %1 */",

                                 op[0], op[1], op[2]);

                          printf ("  mx = 0x%x,", mx);

                          printf ("  ss = 0x%x,", ss);

                          printf ("  rsrc = 0x%x,", rsrc);

                          printf ("  rdst = 0x%x\n", rdst);

                        }

                      SYNTAX("cmp %2%S2, %1");

#line 555 "rx-decode.opc"

                      ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F_OSZC;

                    /*----------------------------------------------------------------------*/

                    /* SUB                  */

                    }

                  break;

              }

            break;

          case 0x05:

              GETBYTE ();

              switch (op[2] & 0x00)

              {

                case 0x00:

                  goto op_semantics_2;

                  break;

              }

            break;

          case 0x06:

              GETBYTE ();

              switch (op[2] & 0x00)

              {

                case 0x00:

                  goto op_semantics_2;

                  break;

              }

            break;

          case 0x07:

              GETBYTE ();

              switch (op[2] & 0x00)

              {

                case 0x00:

                  goto op_semantics_2;

                  break;

              }

            break;

          case 0x08:

              GETBYTE ();

              switch (op[2] & 0x00)

              {

                case 0x00:

                  op_semantics_3:

                    {

                      /** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */

#line 531 "rx-decode.opc"

                      int mx AU = (op[1] >> 6) & 0x03;

#line 531 "rx-decode.opc"

                      int ss AU = op[1] & 0x03;

#line 531 "rx-decode.opc"

                      int rsrc AU = (op[2] >> 4) & 0x0f;

#line 531 "rx-decode.opc"

                      int rdst AU = op[2] & 0x0f;

                      if (trace)

                        {

                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",

                                 "/** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */",

                                 op[0], op[1], op[2]);

                          printf ("  mx = 0x%x,", mx);

                          printf ("  ss = 0x%x,", ss);

                          printf ("  rsrc = 0x%x,", rsrc);

                          printf ("  rdst = 0x%x\n", rdst);

                        }

                      SYNTAX("add %1%S1, %0");

#line 531 "rx-decode.opc"

                      ID(add); SPm(ss, rsrc, mx); DR(rdst); F_OSZC;

                    }

                  break;

              }

            break;

          case 0x09:

              GETBYTE ();

              switch (op[2] & 0x00)

              {

                case 0x00:

                  goto op_semantics_3;

                  break;

              }

            break;

          case 0x0a:

              GETBYTE ();

              switch (op[2] & 0x00)

              {

                case 0x00:

                  goto op_semantics_3;

                  break;

              }

            break;

          case 0x0b:

              GETBYTE ();

              switch (op[2] & 0x00)

              {

                case 0x00:

                  goto op_semantics_3;

                  break;

              }

            break;

          case 0x0c:

              GETBYTE ();

              switch (op[2] & 0x00)

              {

                case 0x00:

                  op_semantics_4:

                    {

                      /** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */

#line 674 "rx-decode.opc"

                      int mx AU = (op[1] >> 6) & 0x03;

#line 674 "rx-decode.opc"

                      int ss AU = op[1] & 0x03;

#line 674 "rx-decode.opc"

                      int rsrc AU = (op[2] >> 4) & 0x0f;

#line 674 "rx-decode.opc"

                      int rdst AU = op[2] & 0x0f;

                      if (trace)

                        {

                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",

                                 "/** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */",

                                 op[0], op[1], op[2]);

                          printf ("  mx = 0x%x,", mx);

                          printf ("  ss = 0x%x,", ss);

                          printf ("  rsrc = 0x%x,", rsrc);

                          printf ("  rdst = 0x%x\n", rdst);

                        }

                      SYNTAX("mul %1%S1, %0");

#line 674 "rx-decode.opc"

                      ID(mul); SPm(ss, rsrc, mx); DR(rdst); F_____;

                    }

                  break;

              }

            break;

          case 0x0d:

              GETBYTE ();

              switch (op[2] & 0x00)

              {

                case 0x00:

                  goto op_semantics_4;

                  break;

              }

            break;

          case 0x0e:

              GETBYTE ();

              switch (op[2] & 0x00)

              {

                case 0x00:

                  goto op_semantics_4;

                  break;

              }

            break;

          case 0x0f:

              GETBYTE ();

              switch (op[2] & 0x00)

              {

                case 0x00:

                  goto op_semantics_4;

                  break;

              }

            break;

          case 0x10:

              GETBYTE ();

              switch (op[2] & 0x00)

              {

                case 0x00:

                  op_semantics_5:

                    {

                      /** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */

#line 444 "rx-decode.opc"

                      int mx AU = (op[1] >> 6) & 0x03;

#line 444 "rx-decode.opc"

                      int ss AU = op[1] & 0x03;

#line 444 "rx-decode.opc"

                      int rsrc AU = (op[2] >> 4) & 0x0f;

#line 444 "rx-decode.opc"

                      int rdst AU = op[2] & 0x0f;

                      if (trace)

                        {

                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",

                                 "/** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */",

                                 op[0], op[1], op[2]);

                          printf ("  mx = 0x%x,", mx);

                          printf ("  ss = 0x%x,", ss);

                          printf ("  rsrc = 0x%x,", rsrc);

                          printf ("  rdst = 0x%x\n", rdst);

                        }

                      SYNTAX("and %1%S1, %0");

#line 444 "rx-decode.opc"

                      ID(and); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;

                    }

                  break;

              }

            break;

          case 0x11:

              GETBYTE ();

              switch (op[2] & 0x00)

              {

                case 0x00:

                  goto op_semantics_5;

                  break;

              }

            break;

          case 0x12:

              GETBYTE ();

              switch (op[2] & 0x00)

              {

                case 0x00:

                  goto op_semantics_5;

                  break;

              }

            break;

          case 0x13:

              GETBYTE ();

              switch (op[2] & 0x00)

              {

                case 0x00:

                  goto op_semantics_5;

                  break;

              }

            break;

          case 0x14:

              GETBYTE ();

              switch (op[2] & 0x00)

              {

                case 0x00:

                  op_semantics_6:

                    {

                      /** 0000 0110 mx01 01ss rsrc rdst     or  %1%S1, %0 */

#line 462 "rx-decode.opc"

                      int mx AU = (op[1] >> 6) & 0x03;

#line 462 "rx-decode.opc"

                      int ss AU = op[1] & 0x03;

#line 462 "rx-decode.opc"

                      int rsrc AU = (op[2] >> 4) & 0x0f;

#line 462 "rx-decode.opc"

                      int rdst AU = op[2] & 0x0f;

                      if (trace)

                        {

                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",

                                 "/** 0000 0110 mx01 01ss rsrc rdst     or  %1%S1, %0 */",

                                 op[0], op[1], op[2]);

                          printf ("  mx = 0x%x,", mx);

                          printf ("  ss = 0x%x,", ss);

                          printf ("  rsrc = 0x%x,", rsrc);

                          printf ("  rdst = 0x%x\n", rdst);

                        }

                      SYNTAX("or  %1%S1, %0");

#line 462 "rx-decode.opc"

                      ID(or); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;

                    }

                  break;

              }

            break;

          case 0x15:

              GETBYTE ();

              switch (op[2] & 0x00)

              {

                case 0x00:

                  goto op_semantics_6;

                  break;

              }

            break;

          case 0x16:

              GETBYTE ();

              switch (op[2] & 0x00)

              {

                case 0x00:

                  goto op_semantics_6;

                  break;

              }

            break;

          case 0x17:

              GETBYTE ();

              switch (op[2] & 0x00)

              {

                case 0x00:

                  goto op_semantics_6;

                  break;

              }

            break;

          case 0x20:

              GETBYTE ();

              switch (op[2] & 0xff)

              {

                case 0x00:

                    GETBYTE ();

                    switch (op[3] & 0x00)

                    {

                      case 0x00:

                        op_semantics_7:

                          {

                            /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */

#line 580 "rx-decode.opc"

                            int mx AU = (op[1] >> 6) & 0x03;

#line 580 "rx-decode.opc"

                            int sp AU = op[1] & 0x03;

#line 580 "rx-decode.opc"

                            int rsrc AU = (op[3] >> 4) & 0x0f;

#line 580 "rx-decode.opc"

                            int rdst AU = op[3] & 0x0f;

                            if (trace)

                              {

                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",

                                       "/** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */",

                                       op[0], op[1], op[2], op[3]);

                                printf ("  mx = 0x%x,", mx);

                                printf ("  sp = 0x%x,", sp);

                                printf ("  rsrc = 0x%x,", rsrc);

                                printf ("  rdst = 0x%x\n", rdst);

                              }

                            SYNTAX("sbb %1%S1, %0");

#line 580 "rx-decode.opc"

                            ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F_OSZC;

                          /*----------------------------------------------------------------------*/

                          /* ABS                  */

                          }

                        break;

                    }

                  break;

                case 0x04:

                    GETBYTE ();

                    switch (op[3] & 0x00)

                    {

                      case 0x00:

                        op_semantics_8:

                          {

                            /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */

#line 619 "rx-decode.opc"

                            int mx AU = (op[1] >> 6) & 0x03;

#line 619 "rx-decode.opc"

                            int ss AU = op[1] & 0x03;

#line 619 "rx-decode.opc"

                            int rsrc AU = (op[3] >> 4) & 0x0f;

#line 619 "rx-decode.opc"

                            int rdst AU = op[3] & 0x0f;

                            if (trace)

                              {

                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",

                                       "/** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */",

                                       op[0], op[1], op[2], op[3]);

                                printf ("  mx = 0x%x,", mx);

                                printf ("  ss = 0x%x,", ss);

                                printf ("  rsrc = 0x%x,", rsrc);

                                printf ("  rdst = 0x%x\n", rdst);

                              }

                            SYNTAX("max %1%S1, %0");

#line 619 "rx-decode.opc"

                            ID(max); SPm(ss, rsrc, mx); DR(rdst);

                          /*----------------------------------------------------------------------*/

                          /* MIN                  */

                          }

                        break;

                    }

                  break;

                case 0x05:

                    GETBYTE ();

                    switch (op[3] & 0x00)

                    {

                      case 0x00:

                        op_semantics_9:

                          {

                            /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */

#line 631 "rx-decode.opc"

                            int mx AU = (op[1] >> 6) & 0x03;

#line 631 "rx-decode.opc"