Subversion Repositories openrisc_me

/* r8c.opc --- semantics for r8c opcodes.                       -*- mode: c -*-

Copyright (C) 2005, 2007, 2008 Free Software Foundation, Inc.

Contributed by Red Hat, Inc.

This file is part of the GNU simulators.

This program 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 of the License, or

(at your option) any later version.

This program 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, see .  */

#include 

#include 

#include "cpu.h"

#include "mem.h"

#include "misc.h"

#include "int.h"

#define AU  __attribute__((unused))

#define tprintf if (trace) printf

static unsigned char

getbyte ()

{

  int tsave = trace;

  unsigned char b;

  if (trace == 1)

    trace = 0;

  b = mem_get_pc ();

  regs.r_pc ++;

  trace = tsave;

  return b;

}

#define M16C_ONLY() /* FIXME: add something here */

#define GETBYTE() (op[opi++] = getbyte())

#define UNSUPPORTED() unsupported("unsupported", orig_pc)

#define NOTYET() unsupported("unimplemented", orig_pc)

static void

unsupported (char *tag, int orig_pc)

{

  int i;

  printf("%s opcode at %08x\n", tag, orig_pc);

  regs.r_pc = orig_pc;

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

    {

      int b = mem_get_pc();

      printf(" %s", bits(b>>4, 4));

      printf(" %s", bits(b, 4));

      regs.r_pc ++;

    }

  printf("\n");

  regs.r_pc = orig_pc;

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

    {

      printf(" %02x", mem_get_pc ());

      regs.r_pc ++;

    }

  printf("\n");

  exit(1);

}

static int

IMM(bw)

{

  int rv = getbyte ();

  if (bw)

    rv = rv + 256 * getbyte();

  if (bw == 2)

    rv = rv + 65536 * getbyte();

  return rv;

}

#define IMM4() (immm >= 8 ? 7 - immm : immm + 1)

#define UNARY_SOP \

  dc = decode_srcdest4 (dest, w); \

  v = sign_ext (get_src (dc), w?16:8);

#define UNARY_UOP \

  dc = decode_srcdest4 (dest, w); \

  v = get_src (dc);

#define BINARY_SOP \

  sc = decode_srcdest4 (srcx, w); \

  dc = decode_srcdest4 (dest, w); \

  a = sign_ext (get_src (sc), w?16:8); \

  b = sign_ext (get_src (dc), w?16:8);

#define BINARY_UOP \

  sc = decode_srcdest4 (srcx, w); \

  dc = decode_srcdest4 (dest, w); \

  a = get_src (sc); \

  b = get_src (dc);

#define carry (FLAG_C ? 1 : 0)

static void

cmp (int d, int s, int w)

{

  int a, b, f=0;

  int mask = w ? 0xffff : 0xff;

  a = d - s;

  b = sign_ext (d, w?16:8) - sign_ext (s, w?16:8);

  tprintf ("cmp: %x - %x = %08x, %x - %x = %d\n",

           d, s, a,

           sign_ext(d,w?16:8), sign_ext(s,w?16:8), b);

  if (b == 0)

    f |= FLAGBIT_Z;

  if (b & (w ? 0x8000 : 0x80))

    f |= FLAGBIT_S;

  if ((d & mask) >= (s & mask))

    f |= FLAGBIT_C;

  if (b < (w ? -32768 : -128) || b > (w ? 32767 : 127))

    f |= FLAGBIT_O;

  set_flags (FLAGBIT_Z | FLAGBIT_S | FLAGBIT_O | FLAGBIT_C, f);

}

static void

div_op (int s, int u, int x, int w)

{

  srcdest sc;

  int v, a, b;

  if (s == -1)

    s = IMM(w);

  else

    {

      sc = decode_srcdest4 (s, w);

      s = get_src (sc);

    }

  v = get_reg (w ? r2r0 : r0);

  if (!u)

    {

      s = sign_ext (s, w ? 16 : 8);

      v = sign_ext (v, w ? 16 : 8);

    }

  if (s == 0)

    {

      set_flags (FLAGBIT_O, FLAGBIT_O);

      return;

    }

  if (u)

    {

      a = (unsigned int)v / (unsigned int)s;

      b = (unsigned int)v % (unsigned int)s;

    }

  else

    {

      a = v / s;

      b = v % s;

    }

  if (x)

    {

      if ((s > 0 && b < 0)

          || (s < 0 && b > 0))

        {

          a --;

          b += s;

        }

    }

  tprintf ("%d / %d = %d rem %d\n", v, s, a, b);

  if ((!u && (a > (w ? 32767 : 127)

             || a < (w ? -32768 : -129)))

      || (u && (a > (w ? 65536 : 255))))

    set_flags (FLAGBIT_O, FLAGBIT_O);

  else

    set_flags (FLAGBIT_O, 0);

  put_reg (w ? r0 : r0l, a);

  put_reg (w ? r2 : r0h, b);

}

static void

rot_op (srcdest sd, int rotc, int count)

{

  int mask = (sd.bytes == 2) ? 0xffff : 0xff;

  int msb = (sd.bytes == 2) ? 0x8000 : 0x80;

  int v = get_src (sd);

  int c = carry, ct;

  tprintf("%s %x by %d\n", rotc ? "rotc" : "rot", v, count);

  tprintf (": %s %d\n", bits(v, 8*sd.bytes), c);

  while (count > 0)

    {

      ct = (v & msb) ? 1 : 0;

      v <<= 1;

      v |= rotc ? c : ct;

      v &= mask;

      c = ct;

      tprintf (": %s %d\n", bits(v, 8*sd.bytes), c);

      count --;

    }

  while (count < 0)

    {

      ct = v & 1;

      v >>= 1;

      v |= (rotc ? c : ct) * msb;

      c = ct;

      tprintf (": %s %d\n", bits(v, 8*sd.bytes), c);

      count ++;

    }

  put_dest (sd, v);

  set_szc (v, sd.bytes, c);

}

static void

shift_op (srcdest sd, int arith, int count)

{

  int mask = (sd.bytes == 2) ? 0xffff : 0xff;

  int msb = (sd.bytes == 2) ? 0x8000 : 0x80;

  int v = get_src (sd);

  int c = 0;

  if (sd.bytes == 4)

    {

      mask = 0xffffffffU;

      msb = 0x80000000U;

      if (count > 16 || count < -16)

        {

          fprintf(stderr, "Error: SI shift of %d undefined\n", count);

          exit(1);

        }

      if (count > 16)

        count = (count - 1) % 16 + 1;

      if (count < -16)

        count = -((-count - 1) % 16 + 1);

    }

  tprintf("%s %x by %d\n", arith ? "sha" : "shl", v, count);

  tprintf (": %s %d\n", bits(v, 8*sd.bytes), c);

  while (count > 0)

    {

      c = (v & msb) ? 1 : 0;

      v <<= 1;

      v &= mask;

      tprintf (": %s %d\n", bits(v, 8*sd.bytes), c);

      count --;

    }

  while (count < 0)

    {

      c = v & 1;

      if (arith)

        v = (v & msb) | (v >> 1);

      else

        v = (v >> 1) & (msb - 1);

      tprintf (": %s %d\n", bits(v, 8*sd.bytes), c);

      count ++;

    }

  put_dest (sd, v);

  set_szc (v, sd.bytes, c);

}

#define MATH_OP(dc,s,c,op,carryrel) \

  a = get_src(dc); \

  b = s & b2mask[dc.bytes]; \

  v2 = a op b op c; \

  tprintf("0x%x " #op " 0x%x " #op " 0x%x = 0x%x\n", a, b, c, v2); \

  a = sign_ext (a, dc.bytes * 8); \

  b = sign_ext (s, dc.bytes * 8); \

  v = a op b op c; \

  tprintf("%d " #op " %d " #op " %d = %d\n", a, b, c, v); \

  set_oszc (v, dc.bytes, v2 carryrel); \

  put_dest (dc, v2);

#define BIT_OP(field,expr) \

  dc = decode_bit (field); \

  b = get_bit (dc); \

  v = expr; \

  tprintf ("b=%d, carry=%d, %s = %d\n", b, carry, #expr, v); \

  put_bit (dc, v);

#define BIT_OPC(field,expr) \

  dc = decode_bit (field); \

  b = get_bit (dc); \

  v = expr; \

  tprintf ("b=%d, carry=%d, %s = %d\n", b, carry, #expr, v); \

  set_c (v);

/* The "BMcnd dest" opcode uses a different encoding for the */

/* condition than other opcodes.  */

static int bmcnd_cond_map[] = {

  0, 1, 2, 3, 8, 9, 10, 11, 4, 5, 6, 7, 12, 13, 14, 15

};

int

decode_r8c()

{

  unsigned char op[40];

  int opi = 0;

  int v, v2, a, b;

  int orig_pc = get_reg (pc);

  srcdest sc, dc;

  int imm;

  step_result = M32C_MAKE_STEPPED ();

  tprintf("trace: decode pc = %05x\n", orig_pc);

  /** VARY dst 011 100 101 110 111 */

  /** 0111 011w 1111 dest  ABS.size dest */

  UNARY_SOP;

  a = v<0 ? -v : v;

  tprintf("abs(%d) = %d\n", v, a);

  set_osz(a, w+1);

  put_dest (dc, a);

  /** 0111 011w 0110 dest  ADC.size #IMM,dest */

  dc = decode_srcdest4(dest, w);

  imm = IMM(w);

  MATH_OP (dc, imm, carry, +, > (w?0xffff:0xff));

  /** 1011 000w srcx dest  ADC.size src,dest */

  sc = decode_srcdest4(srcx, w);

  dc = decode_srcdest4(dest, w);

  b = get_src (sc);

  MATH_OP (dc, b, carry, +, > (w?0xffff:0xff));

  /** 0111 011w 1110 dest  ADCF.size dest */

  dc = decode_srcdest4(dest, w);

  MATH_OP (dc, 0, carry, +, > (w?0xffff:0xff));

  /** 0111 011w 0100 dest  ADD.size:G #imm,dest */

  dc = decode_srcdest4(dest, w);

  imm = IMM(w);

  MATH_OP (dc, imm, 0, +, > (w?0xffff:0xff));

  /** 1100 100w immm dest  ADD.size:Q #IMM,dest */

  dc = decode_srcdest4(dest, w);

  imm = sign_ext (immm, 4);

  MATH_OP (dc, imm, 0, +, > (w?0xffff:0xff));

  /** 1000 0dst            ADD.B:S #IMM8,dst */

  imm = IMM(0);

  dc = decode_dest3 (dst, 0);

  MATH_OP (dc, imm, 0, +, > 0xff);

  /** 1010 000w srcx dest  ADD.size:G src,dest */

  sc = decode_srcdest4(srcx, w);

  dc = decode_srcdest4(dest, w);

  b = get_src (sc);

  MATH_OP (dc, b, 0, +, > (w?0xffff:0xff));

  /** 0010 0d sr           ADD.B:S src,R0L/R0H */

  sc = decode_src2 (sr, 0, d);

  dc = decode_dest1 (d, 0);

  b = get_src (sc);

  MATH_OP (dc, b, 0, +, > 0xff);

  /** 0111 110w 1110 1011  ADD.size:G #IMM,sp */

  dc = reg_sd (sp);

  imm = sign_ext (IMM(w), w?16:8);

  MATH_OP (dc, imm, 0, +, > 0xffff);

  /** 0111 1101 1011 immm  ADD.size:Q #IMM,sp */

  dc = reg_sd (sp);

  imm = sign_ext (immm, 4);

  MATH_OP (dc, imm, 0, +, > 0xffff);

  /** 1111 100w immm dest  ADJNZ.size #IMM,dest,label */

  UNARY_UOP;

  imm = sign_ext(immm, 4);

  tprintf("%x + %d = %x\n", v, imm, v+imm);

  v += imm;

  put_dest (dc, v);

  a = sign_ext (IMM(0), 8);

  if ((v & (w ? 0xffff : 0xff)) != 0)

    {

      tprintf("jmp: %x + 2 + %d = ", get_reg (pc), a);

      put_reg (pc, orig_pc + 2 + a);

      tprintf("%x\n", get_reg (pc));

    }

  /** 0111 011w 0010 dest  AND.size:G #IMM,dest */

  UNARY_UOP;

  imm = IMM(w);

  tprintf ("%x & %x = %x\n", v, imm, v & imm);

  v &= imm;

  set_sz (v, w+1);

  put_dest (dc, v);

  /** 1001 0dst            AND.B:S #IMM8,dest */

  imm = IMM(0);

  dc = decode_dest3 (dst, 0);

  v = get_src (dc);

  tprintf("%x & %x = %x\n", v, imm, v & imm);

  v &= imm;

  set_sz (v, 1);

  put_dest (dc, v);

  /** 1001 000w srcx dest  AND.size:G src.dest */

  BINARY_UOP;

  tprintf ("%x & %x = %x\n", a, b, a & b);

  v = a & b;

  set_sz (v, w+1);

  put_dest (dc, v);

  /** 0001 0d sr           AND.B:S src,R0L/R0H */

  sc = decode_src2 (sr, 0, d);

  dc = decode_dest1 (d, 0);

  a = get_src (sc);

  b = get_src (dc);

  v = a & b;

  tprintf("%x & %x = %x\n", a, b, v);

  set_sz (v, 1);

  put_dest (dc, v);

  /** 0111 1110 0100 srcx  BAND src */

  BIT_OPC (srcx, b & carry);

  /** 0111 1110 1000 dest  BCLR:G dest */

  dc = decode_bit (dest);

  put_bit (dc, 0);

  /** 0100 0bit            BCLR:S bit,base:11[SB] */

  dc = decode_bit11 (bit);

  put_bit (dc, 0);

  /** 0111 1110 0010 dest  BMcnd dest  */

  dc = decode_bit (dest);

  if (condition_true (bmcnd_cond_map [IMM (0) & 15]))

    put_bit (dc, 1);

  else

    put_bit (dc, 0);

  /** 0111 1101 1101 cond  BMcnd C  */

  if (condition_true (cond))

    set_c (1);

  else

    set_c (0);

  /** 0111 1110 0101 srcx  BNAND src */

  BIT_OPC (srcx, !b & carry);

  /** 0111 1110 0111 srcx  BNOR src */

  BIT_OPC (srcx, !b | carry);

  /** 0111 1110 1010 dest  BNOT:G dest */

  BIT_OP (dest, !b);

  /** 0101 0bit            BNOT:S bit,base:11[SB] */

  dc = decode_bit11 (bit);

  put_bit (dc, !get_bit (dc));

  /** 0111 1110 0011 srcx  BNTST src */

  dc = decode_bit (srcx);

  b = get_bit (dc);

  set_zc (!b, !b);

  /** 0111 1110 1101 srcx  BNXOR src */

  BIT_OPC (srcx, !b ^ carry);

  /** 0111 1110 0110 srcx  BOR src */

  BIT_OPC (srcx, b | carry);

  /** 0000 0000            BRK */

  /* We report the break to our caller with the PC still pointing at the

     breakpoint instruction.  */

  put_reg (pc, orig_pc);

  if (verbose)

    printf("[break]\n");

  return M32C_MAKE_HIT_BREAK ();

  /** 0111 1110 1001 dest  BSET:G dest */

  dc = decode_bit (dest);

  put_bit (dc, 1);

  /** 0100 1bit            BSET:S bit,base:11[SB] */

  dc = decode_bit11 (bit);

  put_bit (dc, 1);

  /** 0111 1110 1011 srcx  BTST:G src */

  dc = decode_bit (srcx);

  b = get_bit (dc);

  set_zc (!b, b);

  /** 0101 1bit            BTST:S bit,base:11[SB] */

  dc = decode_bit11 (bit);

  b = get_bit (dc);

  set_zc (!b, b);

  /** 0111 1110 0000 dest  BTSTC dest */

  dc = decode_bit (dest);

  b = get_bit (dc);

  set_zc (!b, b);

  put_bit (dc, 0);

  /** 0111 1110 0001 dest  BTSTS dest */

  dc = decode_bit (dest);

  b = get_bit (dc);

  set_zc (!b, b);

  put_bit (dc, 1);

  /** 0111 1110 1100 srcx  BXOR src */

  BIT_OPC (srcx, b ^ carry);

  /** 0111 011w 1000 dest  CMP.size:G #IMM,dest */

  UNARY_UOP;

  imm = IMM(w);

  cmp (v, imm, w);

  /** 1101 000w immm dest  CMP.size:Q #IMM,dest */

  UNARY_UOP;

  immm = sign_ext (immm, 4);

  cmp (v, immm, w);

  /** 1110 0dst            CMP.B:S #IMM8,dest */

  imm = IMM(0);

  dc = decode_dest3 (dst, 0);

  v = get_src (dc);

  cmp (v, imm, 0);

  /** 1100 000w srcx dest  CMP.size:G src,dest */

  BINARY_UOP;

  cmp(b, a, w);

  /** 0011 1d sr           CMP.B:S src,R0L/R0H */

  sc = decode_src2 (sr, 0, d);

  dc = decode_dest1 (d, 0);

  a = get_src (sc);

  b = get_src (dc);

  cmp (b, a, 0);

  /** 0111 110w 1110 i1c s  DADC,DADD,DSBB,DSUB */

  /* w = width, i = immediate, c = carry, s = subtract */

  int src = i ? IMM(w) : get_reg (w ? r1 : r0h);

  int dest = get_reg (w ? r0 : r0l);

  int res;

  src = bcd2int(src, w);

  dest = bcd2int(dest, w);

  tprintf("decimal: %d %s %d", dest, s?"-":"+", src);

  if (c)

    tprintf(" c=%d", carry);

  if (!s)

    {

      res = dest + src;

      if (c)

        res += carry;

      c = res > (w ? 9999 : 99);

    }

  else

    {

      res = dest - src;

      if (c)

        res -= (1-carry);

      c = res >= 0;

      if (res < 0)

        res += w ? 10000 : 100;

    }

  res = int2bcd (res, w);

  tprintf(" = %x\n", res);

  set_szc (res, w+1, c);

  put_reg (w ? r0 : r0l, res);

  /** 1010 1dst            DEC.B dest */

  dc = decode_dest3 (dst, 0);

  v = get_src (dc);

  tprintf("%x -- = %x\n", v, v-1);

  v --;

  set_sz (v, 1);

  put_dest (dc, v);

  /** 1111 d010            DEC.W dest */

  v = get_reg (d ? a1 : a0);

  tprintf("%x -- = %x\n", v, v-1);

  v --;

  set_sz (v, 2);

  put_reg (d ? a1 : a0, v);

  /** 0111 110w 1110 0001  DIV.size #IMM */

  div_op (-1, 0, 0, w);

  /** 0111 011w 1101 srcx  DIV.size src */

  div_op (srcx, 0, 0, w);

  /** 0111 110w 1110 0000  DIVU.size #IMM */

  div_op (-1, 1, 0, w);

  /** 0111 011w 1100 srcx  DIVU.size src */

  div_op (srcx, 1, 0, w);

  /** 0111 110w 1110 0011  DIVX.size #IMM */

  div_op (-1, 0, 1, w);

  /** 0111 011w 1001 srcx  DIVX.size src */

  div_op (srcx, 0, 1, w);

  /** 0111 1100 1111 0010  ENTER #IMM8 */

  imm = IMM(0);

  put_reg (sp, get_reg (sp) - 2);

  mem_put_hi (get_reg (sp), get_reg (fb));

  put_reg (fb, get_reg (sp));

  put_reg (sp, get_reg (sp) - imm);

  /** 0111 1101 1111 0010  EXITD */

  put_reg (sp, get_reg (fb));

  put_reg (fb, mem_get_hi (get_reg (sp)));

  put_reg (sp, get_reg (sp) + 2);

  put_reg (pc, mem_get_psi (get_reg (sp)));

  put_reg (sp, get_reg (sp) + 3);

  /** 0111 1100 0110 dest  EXTS.B dest */

  dc = decode_srcdest4 (dest, 0);

  v = sign_ext (get_src (dc), 8);

  dc = widen_sd (dc);

  put_dest (dc, v);

  set_sz (v, 1);

  /** 0111 1100 1111 0011  EXTS.W R0 */

  v = sign_ext (get_reg (r0), 16);

  put_reg (r2r0, v);

  set_sz (v, 2);

  /** 1110 1011 0flg 0101  FCLR dest */

  set_flags (1 << flg, 0);

  /** 1110 1011 0flg 0100  FSET dest */

  set_flags (1 << flg, 1 << flg);

  /** 1010 0dst            INC.B dest */

  dc = decode_dest3 (dst, 0);

  v = get_src (dc);

  tprintf("%x ++ = %x\n", v, v+1);

  v ++;

  set_sz (v, 1);

  put_dest (dc, v);

  /** 1011 d010            INC.W dest */

  v = get_reg (d ? a1 : a0);

  tprintf("%x ++ = %x\n", v, v+1);

  v ++;

  set_sz (v, 2);

  put_reg (d ? a1 : a0, v);

  /** 1110 1011 11vector   INT #imm */

  trigger_based_interrupt (vector);

  /** 1111 0110            INTO */

  if (FLAG_O)

    trigger_fixed_interrupt (0xffe0);

  /** 0110 1cnd            Jcnd label */

  v = sign_ext (IMM(0), 8);

  if (condition_true (cnd))

    put_reg (pc, orig_pc + 1 + v);

  /** 0111 1101 1100 cond  Jcnd label */

  v = sign_ext (IMM(0), 8);

  if (condition_true (cond))

    put_reg (pc, orig_pc + 2 + v);

  /** 0110 0dsp            JMP.S label */

  put_reg (pc, orig_pc + 2 + dsp);

  /** 1111 1110            JMP.B label */

  imm = sign_ext (IMM(0), 8);

  if (imm == -1)

    {

      if (verbose)

        printf("[jmp-to-self detected as exit]\n");

      return M32C_MAKE_HIT_BREAK ();

    }

  put_reg (pc, orig_pc + 1 + imm);

  /** 1111 0100            JMP.W label */

  imm = sign_ext (IMM(1), 16);

  put_reg (pc, orig_pc + 1 + imm);

  /** 1111 1100            JMP.A label */

  imm = IMM(2);

  put_reg (pc, imm);

  /** 0111 1101 0010 srcx  JMPI.W src */

  sc = decode_jumpdest (srcx, 1);

  a = get_src (sc);

  a = sign_ext (a, 16);

  put_reg (pc, orig_pc + a);

  /** 0111 1101 0000 srcx  JMPI.A src */

  sc = decode_jumpdest (srcx, 0);

  a = get_src (sc);

  put_reg (pc, a);

  /** 1110 1110            JMPS #IMM8 */

  M16C_ONLY();

  imm = IMM(0);

  a = 0xf0000 + mem_get_hi (0xffffe - imm * 2);

  put_reg (pc, a);

  /** 1111 0101            JSR.W label */

  imm = sign_ext (IMM(1), 16);

  put_reg (sp, get_reg (sp) - 3);

  mem_put_psi (get_reg (sp), get_reg (pc));

  put_reg (pc, orig_pc + imm + 1);

  /** 1111 1101            JSR.A label */

  imm = IMM(2);

  put_reg (sp, get_reg (sp) - 3);

  mem_put_psi (get_reg (sp), get_reg (pc));

  put_reg (pc, imm);

  /** 0111 1101 0011 srcx  JSRI.W src */

  sc = decode_jumpdest (srcx, 1);

  a = get_src (sc);

  a = sign_ext (a, 16);

  put_reg (sp, get_reg (sp) - 3);

  mem_put_psi (get_reg (sp), get_reg (pc));

  put_reg (pc, orig_pc + a);

  /** 0111 1101 0001 srcx  JSRI.A src */

  sc = decode_jumpdest (srcx, 0);

  a = get_src (sc);

  put_reg (sp, get_reg (sp) - 3);

  mem_put_psi (get_reg (sp), get_reg (pc));

  put_reg (pc, a);

  /** 1110 1111            JSRS #IMM8 */

  M16C_ONLY();

  imm = IMM(0);

  a = 0xf0000 + mem_get_hi (0xffffe - imm * 2);

  put_reg (sp, get_reg (sp) - 3);

  mem_put_psi (get_reg (sp), get_reg (pc));

  put_reg (pc, a);

  /** 1110 1011 0reg 0000  LDC #IMM16,dest */

  dc = decode_cr (reg);

  imm = IMM(1);

  put_dest (dc, imm);

  /** 0111 1010 1reg srcx  LDC src,dest */

  dc = decode_cr (reg);

  sc = decode_srcdest4 (srcx,1);

  put_dest (dc, get_src (sc));

  /** 0111 1100 1111 0000  LDCTX abs16,abs20 */

  NOTYET();

  /** 0111 010w 1000 dest  LDE.size abs20,dest */

  dc = decode_srcdest4 (dest, w);

  imm = IMM(2);

  if (w)

    v = mem_get_hi (imm);

  else

    v = mem_get_qi (imm);

  put_dest (dc, v);

  /** 0111 010w 1001 dest  LDE.size dsp:20[a0], dest */

  dc = decode_srcdest4 (dest, w);

  imm = IMM(2) + get_reg (a0);

  if (w)

    v = mem_get_hi (imm);

  else

    v = mem_get_qi (imm);

  put_dest (dc, v);

  /** 0111 010w 1010 dest  LDE.size [a1a0],dest */

  dc = decode_srcdest4 (dest, w);

  imm = get_reg (a1a0);

  if (w)

    v = mem_get_hi (imm);

  else

    v = mem_get_qi (imm);

  put_dest (dc, v);

  /** 0111 1101 1010 0imm  LDIPL #IMM */

  set_flags (0x700, imm*0x100);

  /** 0111 010w 1100 dest  MOV.size:G #IMM,dest */

  dc = decode_srcdest4 (dest, w);

  imm = IMM(w);

  v = imm;

  tprintf("%x = %x\n", v, v);

  set_sz(v, w+1);

  put_dest (dc, v);

  /** 1101 100w immm dest  MOV.size:Q #IMM,dest */

  dc = decode_srcdest4 (dest, w);

  v = sign_ext (immm, 4);

  tprintf ("%x = %x\n", v, v);

  set_sz (v, w+1);

  put_dest (dc, v);

  /** 1100 0dst            MOV.B:S #IMM8,dest */

  imm = IMM(0);

  dc = decode_dest3 (dst, 0);

  v = imm;

  tprintf("%x = %x\n", v, v);

  set_sz (v, 1);

  put_dest (dc, v);

  /** 1w10 d010            MOV.size:S #IMM,dest */

  /* Note that for w, 0=W and 1=B unlike the usual meaning.  */

  v = IMM(1-w);

  tprintf("%x = %x\n", v, v);

  set_sz (v, 2-w);

  put_reg (d ? a1 : a0, v);

  /** 1011 0dst            MOV.B:Z #0,dest */

  dc = decode_dest3 (dst, 0);

  v = 0;

  set_sz (v, 1);

  put_dest (dc, v);

  /** 0111 001w srcx dest  MOV.size:G src,dest */

  sc = decode_srcdest4 (srcx, w);

  dc = decode_srcdest4 (dest, w);

  v = get_src (sc);

  set_sz (v, w+1);

  put_dest (dc, v);

  /** 0011 0d sr           MOV.B:S src,dest */

  sc = decode_src2 (sr, 0, d);

  v = get_src (sc);

  set_sz (v, 1);

  put_reg (d ? a1 : a0, v);