Subversion Repositories openrisc

#line 1 "rx-decode.opc"

/* -*- c -*- */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "config.h"

#include "ansidecl.h"

#include "opcode/rx.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

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

static int bwl[] =

{

  RX_Byte,

  RX_Word,

  RX_Long

};

static int sbwl[] =

{

  RX_SByte,

  RX_SWord,

  RX_Long

};

static int ubwl[] =

{

  RX_UByte,

  RX_UWord,

  RX_Long

};

static int memex[] =

{

  RX_SByte,

  RX_SWord,

  RX_Long,

  RX_UWord

};

#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 };

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

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

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) * 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 SC(i)       OP (1, RX_Operand_Immediate, 0, i)

#define SR(r)       OP (1, RX_Operand_Register,  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) * 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 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) * 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 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 uBWL(sz)    rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = ubwl[sz]

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

#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, 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_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 * 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 * PSCALE[size];

      break;

    default:

      abort ();

    }

}

/* The syntax is "OSZC" where each character is one of the following:

   - = flag unchanged

   1 = flag set

   ? = flag undefined

   x = flag set (any letter will do, use it for hints :).  */

static void

store_flags (RX_Opcode_Decoded * rx, char * str)

{

  int i, mask;

  rx->flags_0 = 0;

  rx->flags_1 = 0;

  rx->flags_s = 0;

  for (i = 0; i < 4; i++)

    {

      mask = 8 >> i;

      switch (str[i])

        {

        case 0:

          abort ();

        case '-':

          break;

        case '0':

          rx->flags_0 |= mask;

          break;

        case '1':

          rx->flags_1 |= mask;

          break;

        case '?':

          break;

        default:

          rx->flags_0 |= mask;

          rx->flags_s |= mask;

          break;

        }

    }

}

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 951 "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 954 "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 740 "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 746 "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 718 "rx-decode.opc"

          ID(branch); Scc(RXC_always); 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 734 "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 522 "rx-decode.opc"

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

#line 522 "rx-decode.opc"

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

#line 522 "rx-decode.opc"

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

#line 522 "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 522 "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 510 "rx-decode.opc"

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

#line 510 "rx-decode.opc"

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

#line 510 "rx-decode.opc"

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

#line 510 "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 510 "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 486 "rx-decode.opc"

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

#line 486 "rx-decode.opc"

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

#line 486 "rx-decode.opc"

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

#line 486 "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 486 "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 583 "rx-decode.opc"

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

#line 583 "rx-decode.opc"

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

#line 583 "rx-decode.opc"

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

#line 583 "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 583 "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 399 "rx-decode.opc"

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

#line 399 "rx-decode.opc"

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

#line 399 "rx-decode.opc"

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

#line 399 "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);