[deliverable/binutils-gdb.git] / sim / m32c / srcdest.c

/* srcdest.c --- decoding M32C addressing modes.

Copyright (C) 2005-2016 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 <http://www.gnu.org/licenses/>.  */


#include <stdio.h>
#include <stdlib.h>

#include "cpu.h"
#include "mem.h"

static int src_indirect = 0;
static int dest_indirect = 0;
static int src_addend = 0;
static int dest_addend = 0;

static int
disp8 (void)
{
  int rv;
  int tsave = trace;

  if (trace == 1)
    trace = 0;
  rv = mem_get_qi (get_reg (pc));
  regs.r_pc++;
  trace = tsave;
  return rv;
}

static int
disp16 (void)
{
  int rv;
  int tsave = trace;

  if (trace == 1)
    trace = 0;
  rv = mem_get_hi (get_reg (pc));
  regs.r_pc += 2;
  trace = tsave;
  return rv;
}

static int
disp24 (void)
{
  int rv;
  int tsave = trace;

  if (trace == 1)
    trace = 0;
  rv = mem_get_psi (get_reg (pc));
  regs.r_pc += 3;
  trace = tsave;
  return rv;
}

static int
disp20 (void)
{
  return disp24 () & 0x000fffff;
}

const char *
bits (int v, int b)
{
  static char buf[17];
  char *bp = buf + 16;
  *bp = 0;
  while (b)
    {
      *--bp = (v & 1) ? '1' : '0';
      v >>= 1;
      b--;
    }
  return bp;
}

static const char *the_bits = 0;

void
decode_indirect (int si, int di)
{
  src_indirect = si;
  dest_indirect = di;
  if (trace && (si || di))
    printf ("indirect: s:%d d:%d\n", si, di);
}

void
decode_index (int sa, int da)
{
  src_addend = sa;
  dest_addend = da;
  if (trace && (sa || da))
    printf ("index: s:%d d:%d\n", sa, da);
}

srcdest
decode_srcdest4 (int destcode, int bw)
{
  srcdest sd;
  static const char *dc_wnames[16] = { "r0", "r1", "r2", "r3",
    "a0", "a1", "[a0]", "[a1]",
    "disp8[a0]", "disp8[a1]", "disp8[sb]", "disp8[fb]",
    "disp16[a0]", "disp16[a1]", "disp16[sb]", "disp16"
  };
  static const char *dc_bnames[4] = { "r0l", "r0h", "r1l", "r1h" };;

  sd.bytes = bw ? 2 : 1;
  sd.mem = (destcode >= 6) ? 1 : 0;

  if (trace)
    {
      const char *n = dc_wnames[destcode];
      if (bw == 0 && destcode <= 3)
	n = dc_bnames[destcode];
      if (!the_bits)
	the_bits = bits (destcode, 4);
      printf ("decode: %s (%d) : %s\n", the_bits, destcode, n);
      the_bits = 0;
    }

  switch (destcode)
    {
    case 0x0:
      sd.u.reg = bw ? r0 : r0l;
      break;
    case 0x1:
      sd.u.reg = bw ? r1 : r0h;
      break;
    case 0x2:
      sd.u.reg = bw ? r2 : r1l;
      break;
    case 0x3:
      sd.u.reg = bw ? r3 : r1h;
      break;
    case 0x4:
      sd.u.reg = a0;
      break;
    case 0x5:
      sd.u.reg = a1;
      break;
    case 0x6:
      sd.u.addr = get_reg (a0);
      break;
    case 0x7:
      sd.u.addr = get_reg (a1);
      break;
    case 0x8:
      sd.u.addr = get_reg (a0) + disp8 ();
      break;
    case 0x9:
      sd.u.addr = get_reg (a1) + disp8 ();
      break;
    case 0xa:
      sd.u.addr = get_reg (sb) + disp8 ();
      break;
    case 0xb:
      sd.u.addr = get_reg (fb) + sign_ext (disp8 (), 8);
      break;
    case 0xc:
      sd.u.addr = get_reg (a0) + disp16 ();
      break;
    case 0xd:
      sd.u.addr = get_reg (a1) + disp16 ();
      break;
    case 0xe:
      sd.u.addr = get_reg (sb) + disp16 ();
      break;
    case 0xf:
      sd.u.addr = disp16 ();
      break;
    default:
      abort ();
    }
  if (sd.mem)
    sd.u.addr &= addr_mask;
  return sd;
}

srcdest
decode_jumpdest (int destcode, int w)
{
  srcdest sd;
  static const char *dc_wnames[16] = { "r0", "r1", "r2", "r3",
    "a0", "a1", "[a0]", "[a1]",
    "disp8[a0]", "disp8[a1]", "disp8[sb]", "disp8[fb]",
    "disp20[a0]", "disp20[a1]", "disp16[sb]", "abs16"
  };
  static const char *dc_anames[4] = { "r0l", "r0h", "r1l", "r1h" };

  sd.bytes = w ? 2 : 3;
  sd.mem = (destcode >= 6) ? 1 : 0;

  if (trace)
    {
      const char *n = dc_wnames[destcode];
      if (w == 0 && destcode <= 3)
	n = dc_anames[destcode];
      if (!the_bits)
	the_bits = bits (destcode, 4);
      printf ("decode: %s : %s\n", the_bits, n);
      the_bits = 0;
    }

  switch (destcode)
    {
    case 0x0:
      sd.u.reg = w ? r0 : r2r0;
      break;
    case 0x1:
      sd.u.reg = w ? r1 : r2r0;
      break;
    case 0x2:
      sd.u.reg = w ? r2 : r3r1;
      break;
    case 0x3:
      sd.u.reg = w ? r3 : r3r1;
      break;
    case 0x4:
      sd.u.reg = w ? a0 : a1a0;
      break;
    case 0x5:
      sd.u.reg = w ? a1 : a1a0;
      break;
    case 0x6:
      sd.u.addr = get_reg (a0);
      break;
    case 0x7:
      sd.u.addr = get_reg (a1);
      break;
    case 0x8:
      sd.u.addr = get_reg (a0) + disp8 ();
      break;
    case 0x9:
      sd.u.addr = get_reg (a1) + disp8 ();
      break;
    case 0xa:
      sd.u.addr = get_reg (sb) + disp8 ();
      break;
    case 0xb:
      sd.u.addr = get_reg (fb) + sign_ext (disp8 (), 8);
      break;
    case 0xc:
      sd.u.addr = get_reg (a0) + disp20 ();
      break;
    case 0xd:
      sd.u.addr = get_reg (a1) + disp20 ();
      break;
    case 0xe:
      sd.u.addr = get_reg (sb) + disp16 ();
      break;
    case 0xf:
      sd.u.addr = disp16 ();
      break;
    default:
      abort ();
    }
  if (sd.mem)
    sd.u.addr &= addr_mask;
  return sd;
}

srcdest
decode_dest3 (int destcode, int bw)
{
  static char map[8] = { -1, -1, -1, 1, 0, 10, 11, 15 };

  the_bits = bits (destcode, 3);
  return decode_srcdest4 (map[destcode], bw);
}

srcdest
decode_src2 (int srccode, int bw, int d)
{
  static char map[4] = { 0, 10, 11, 15 };

  the_bits = bits (srccode, 2);
  return decode_srcdest4 (srccode ? map[srccode] : 1 - d, bw);
}

static struct
{
  reg_id b_regno;
  reg_id w_regno;
  int is_memory;
  int disp_bytes;
  char *name;
} modes23[] =
{
  {
  a0, a0, 1, 0, "[A0]"},	/* 0 0 0 0 0 */
  {
  a1, a1, 1, 0, "[A1]"},	/* 0 0 0 0 1 */
  {
  a0, a0, 0, 0, "A0"},		/* 0 0 0 1 0 */
  {
  a1, a1, 0, 0, "A1"},		/* 0 0 0 1 1 */
  {
  a0, a0, 1, 1, "dsp:8[A0]"},	/* 0 0 1 0 0 */
  {
  a1, a1, 1, 1, "dsp:8[A1]"},	/* 0 0 1 0 1 */
  {
  sb, sb, 1, 1, "dsp:8[SB]"},	/* 0 0 1 1 0 */
  {
  fb, fb, 1, -1, "dsp:8[FB]"},	/* 0 0 1 1 1 */
  {
  a0, a0, 1, 2, "dsp:16[A0]"},	/* 0 1 0 0 0 */
  {
  a1, a1, 1, 2, "dsp:16[A1]"},	/* 0 1 0 0 1 */
  {
  sb, sb, 1, 2, "dsp:16[SB]"},	/* 0 1 0 1 0 */
  {
  fb, fb, 1, -2, "dsp:16[FB]"},	/* 0 1 0 1 1 */
  {
  a0, a0, 1, 3, "dsp:24[A0]"},	/* 0 1 1 0 0 */
  {
  a1, a1, 1, 3, "dsp:24[A1]"},	/* 0 1 1 0 1 */
  {
  mem, mem, 1, 3, "abs24"},	/* 0 1 1 1 0 */
  {
  mem, mem, 1, 2, "abs16"},	/* 0 1 1 1 1 */
  {
  r0h, r2, 0, 0, "R0H/R2"},	/* 1 0 0 0 0 */
  {
  r1h, r3, 0, 0, "R1H/R3"},	/* 1 0 0 0 1 */
  {
  r0l, r0, 0, 0, "R0L/R0"},	/* 1 0 0 1 0 */
  {
  r1l, r1, 0, 0, "R1L/R1"},	/* 1 0 0 1 1 */
};

static srcdest
decode_sd23 (int bbb, int bb, int bytes, int ind, int add)
{
  srcdest sd;
  int code = (bbb << 2) | bb;

  if (code >= sizeof (modes23) / sizeof (modes23[0]))
    abort ();

  if (trace)
    {
      char *b1 = "";
      char *b2 = "";
      char ad[30];
      if (ind)
	{
	  b1 = "[";
	  b2 = "]";
	}
      if (add)
	sprintf (ad, "%+d", add);
      else
	ad[0] = 0;
      if (!the_bits)
	the_bits = bits (code, 4);
      printf ("decode: %s (%d) : %s%s%s%s\n", the_bits, code, b1,
	      modes23[code].name, ad, b2);
      the_bits = 0;
    }

  sd.bytes = bytes;
  sd.mem = modes23[code].is_memory;
  if (sd.mem)
    {
      if (modes23[code].w_regno == mem)
	sd.u.addr = 0;
      else
	sd.u.addr = get_reg (modes23[code].w_regno);
      switch (modes23[code].disp_bytes)
	{
	case 1:
	  sd.u.addr += disp8 ();
	  break;
	case 2:
	  sd.u.addr += disp16 ();
	  break;
	case -1:
	  sd.u.addr += sign_ext (disp8 (), 8);
	  break;
	case -2:
	  sd.u.addr += sign_ext (disp16 (), 16);
	  break;
	case 3:
	  sd.u.addr += disp24 ();
	  break;
	default:
	  break;
	}
      if (add)
	sd.u.addr += add;
      if (ind)
	sd.u.addr = mem_get_si (sd.u.addr & membus_mask);
      sd.u.addr &= membus_mask;
    }
  else
    {
      sd.u.reg = (bytes > 1) ? modes23[code].w_regno : modes23[code].b_regno;
      if (bytes == 3 || bytes == 4)
	{
	  switch (sd.u.reg)
	    {
	    case r0:
	      sd.u.reg = r2r0;
	      break;
	    case r1:
	      sd.u.reg = r3r1;
	      break;
	    case r2:
	      abort ();
	    case r3:
	      abort ();
	    default:;
	    }
	}

    }
  return sd;
}

srcdest
decode_dest23 (int ddd, int dd, int bytes)
{
  return decode_sd23 (ddd, dd, bytes, dest_indirect, dest_addend);
}

srcdest
decode_src23 (int sss, int ss, int bytes)
{
  return decode_sd23 (sss, ss, bytes, src_indirect, src_addend);
}

srcdest
decode_dest2 (int dd, int bytes)
{
  /* r0l/r0, abs16, dsp:8[SB], dsp:8[FB] */
  static char map[4] = { 0x12, 0x0f, 0x06, 0x07 };

  the_bits = bits (dd, 2);
  return decode_sd23 (map[dd] >> 2, map[dd] & 3, bytes, dest_indirect,
		      dest_addend);
}

srcdest
decode_src3 (int sss, int bytes)
{
  /* r0, r1, a0, a1, r2, r3, N/A, N/A */
  static char map[8] = { 0x12, 0x13, 0x02, 0x03, 0x10, 0x11, 0, 0 };

  the_bits = bits (sss, 3);
  return decode_sd23 (map[sss] >> 2, map[sss] & 3, bytes, src_indirect,
		      src_addend);
}

srcdest
decode_dest1 (int destcode, int bw)
{
  the_bits = bits (destcode, 1);
  return decode_srcdest4 (destcode, bw);
}

srcdest
decode_cr (int crcode)
{
  static int regcode[] = { 0, intbl, intbh, flags, isp, sp, sb, fb };
  srcdest sd;
  sd.mem = 0;
  sd.bytes = 2;
  sd.u.reg = regcode[crcode & 7];
  return sd;
}

srcdest
decode_cr_b (int crcode, int bank)
{
  /* FIXME: intbl, intbh, isp */
  static int regcode[3][8] = {
    {0, 0, flags, 0, 0, 0, 0, 0},
    {intb, sp, sb, fb, 0, 0, 0, isp},
    {0, 0, 0, 0, 0, 0, 0, 0}
  };
  srcdest sd;
  sd.mem = 0;
  sd.bytes = bank ? 3 : 2;
  sd.u.reg = regcode[bank][crcode & 7];
  return sd;
}

srcdest
widen_sd (srcdest sd)
{
  sd.bytes *= 2;
  if (!sd.mem)
    switch (sd.u.reg)
      {
      case r0l:
	sd.u.reg = r0;
	break;
      case r0:
	sd.u.reg = r2r0;
	break;
      case r1l:
	sd.u.reg = r1;
	break;
      case r1:
	sd.u.reg = r3r1;
	break;
      case a0:
	if (A16)
	  sd.u.reg = a1a0;
	break;
      default:
	break;
      }
  return sd;
}

srcdest
reg_sd (reg_id reg)
{
  srcdest rv;
  rv.bytes = reg_bytes[reg];
  rv.mem = 0;
  rv.u.reg = reg;
  return rv;
}

int
get_src (srcdest sd)
{
  int v;
  if (sd.mem)
    {
      switch (sd.bytes)
	{
	case 1:
	  v = mem_get_qi (sd.u.addr);
	  break;
	case 2:
	  v = mem_get_hi (sd.u.addr);
	  break;
	case 3:
	  v = mem_get_psi (sd.u.addr);
	  break;
	case 4:
	  v = mem_get_si (sd.u.addr);
	  break;
	default:
	  abort ();
	}
    }
  else
    {
      v = get_reg (sd.u.reg);
      switch (sd.bytes)
	{
	case 1:
	  v &= 0xff;
	  break;
	case 2:
	  v &= 0xffff;
	  break;
	case 3:
	  v &= 0xffffff;
	  break;
	}
    }
  return v;
}

void
put_dest (srcdest sd, int v)
{
  if (sd.mem)
    {
      switch (sd.bytes)
	{
	case 1:
	  mem_put_qi (sd.u.addr, v);
	  break;
	case 2:
	  mem_put_hi (sd.u.addr, v);
	  break;
	case 3:
	  mem_put_psi (sd.u.addr, v);
	  break;
	case 4:
	  mem_put_si (sd.u.addr, v);
	  break;
	}
    }
  else
    {
      switch (sd.bytes)
	{
	case 1:
	  v &= 0xff;
	  break;
	case 2:
	  v &= 0xffff;
	  break;
	case 3:
	  v &= 0xffffff;
	  break;
	}
      put_reg (sd.u.reg, v);
    }
}

srcdest
decode_bit (int destcode)
{
  srcdest sd;
  int addr = 0;
  static const char *dc_names[] = { "r0", "r1", "r2", "r3",
    "a0", "a1", "[a0]", "[a1]",
    "disp8[a0]", "disp8[a1]", "disp8[sb]", "disp8[fb]",
    "disp16[a0]", "disp16[a1]", "disp16[sb]", "abs16"
  };

  if (trace)
    {
      const char *the_bits = bits (destcode, 4);
      printf ("decode: %s : %s\n", the_bits, dc_names[destcode]);
    }

  switch (destcode)
    {
    case 0:
      sd.u.reg = r0;
      break;
    case 1:
      sd.u.reg = r1;
      break;
    case 2:
      sd.u.reg = r2;
      break;
    case 3:
      sd.u.reg = r3;
      break;
    case 4:
      sd.u.reg = a0;
      break;
    case 5:
      sd.u.reg = a1;
      break;
    case 6:
      addr = get_reg (a0);
      break;
    case 7:
      addr = get_reg (a1);
      break;
    case 8:
      addr = get_reg (a0) + disp8 ();
      break;
    case 9:
      addr = get_reg (a1) + disp8 ();
      break;
    case 10:
      addr = get_reg (sb) * 8 + disp8 ();
      break;
    case 11:
      addr = get_reg (fb) * 8 + sign_ext (disp8 (), 8);
      break;
    case 12:
      addr = get_reg (a0) + disp16 ();
      break;
    case 13:
      addr = get_reg (a1) + disp16 ();
      break;
    case 14:
      addr = get_reg (sb) + disp16 ();
      break;
    case 15:
      addr = disp16 ();
      break;
    }

  if (destcode < 6)
    {
      int d = disp8 ();
      sd.mem = 0;
      sd.mask = 1 << (d & 0x0f);
    }
  else
    {
      addr &= addr_mask;
      sd.mem = 1;
      sd.mask = 1 << (addr & 7);
      sd.u.addr = addr >> 3;
    }
  return sd;
}

srcdest
decode_bit11 (int op0)
{
  srcdest sd;
  sd.mask = 1 << (op0 & 7);
  sd.mem = 1;
  sd.u.addr = get_reg (sb) + disp8 ();
  return sd;
}

int
get_bit (srcdest sd)
{
  int b;
  if (sd.mem)
    b = mem_get_qi (sd.u.addr) & sd.mask;
  else
    b = get_reg (sd.u.reg) & sd.mask;
  return b ? 1 : 0;
}

void
put_bit (srcdest sd, int val)
{
  int b;
  if (sd.mem)
    b = mem_get_qi (sd.u.addr);
  else
    b = get_reg (sd.u.reg);
  if (val)
    b |= sd.mask;
  else
    b &= ~sd.mask;
  if (sd.mem)
    mem_put_qi (sd.u.addr, b);
  else
    put_reg (sd.u.reg, b);
}

int
get_bit2 (srcdest sd, int bit)
{
  int b;
  if (sd.mem)
    b = mem_get_qi (sd.u.addr + (bit >> 3)) & (1 << (bit & 7));
  else
    b = get_reg (sd.u.reg) & (1 << bit);
  return b ? 1 : 0;
}

void
put_bit2 (srcdest sd, int bit, int val)
{
  int b;
  if (sd.mem)
    b = mem_get_qi (sd.u.addr + (bit >> 3));
  else
    b = get_reg (sd.u.reg);
  if (val)
    b |= (1 << (bit & 7));
  else
    b &= ~(1 << (bit & 7));
  if (sd.mem)
    mem_put_qi (sd.u.addr + (bit >> 3), b);
  else
    put_reg (sd.u.reg, b);
}
Commit	Line	Data
d45a4bef JB	1	/* srcdest.c --- decoding M32C addressing modes.
d45a4bef JB	2
618f726f	3	Copyright (C) 2005-2016 Free Software Foundation, Inc.
d45a4bef JB	4	Contributed by Red Hat, Inc.
	5
	6	This file is part of the GNU simulators.
	7
4744ac1b JB	8	This program is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 3 of the License, or
	11	(at your option) any later version.
d45a4bef	12
4744ac1b JB	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
d45a4bef JB	17
d45a4bef JB	18	You should have received a copy of the GNU General Public License
4744ac1b	19	along with this program. If not, see <http://www.gnu.org/licenses/>. */
d45a4bef JB	20
	21
	22	#include <stdio.h>
	23	#include <stdlib.h>
	24
	25	#include "cpu.h"
	26	#include "mem.h"
	27
	28	static int src_indirect = 0;
	29	static int dest_indirect = 0;
	30	static int src_addend = 0;
	31	static int dest_addend = 0;
	32
	33	static int
269e9c18	34	disp8 (void)
d45a4bef JB	35	{
	36	int rv;
	37	int tsave = trace;
	38
	39	if (trace == 1)
	40	trace = 0;
	41	rv = mem_get_qi (get_reg (pc));
	42	regs.r_pc++;
	43	trace = tsave;
	44	return rv;
	45	}
	46
	47	static int
269e9c18	48	disp16 (void)
d45a4bef JB	49	{
	50	int rv;
	51	int tsave = trace;
	52
	53	if (trace == 1)
	54	trace = 0;
	55	rv = mem_get_hi (get_reg (pc));
	56	regs.r_pc += 2;
	57	trace = tsave;
	58	return rv;
	59	}
	60
	61	static int
269e9c18	62	disp24 (void)
d45a4bef JB	63	{
	64	int rv;
	65	int tsave = trace;
	66
	67	if (trace == 1)
	68	trace = 0;
	69	rv = mem_get_psi (get_reg (pc));
	70	regs.r_pc += 3;
	71	trace = tsave;
	72	return rv;
	73	}
	74
	75	static int
269e9c18	76	disp20 (void)
d45a4bef JB	77	{
	78	return disp24 () & 0x000fffff;
	79	}
	80
	81	const char *
	82	bits (int v, int b)
	83	{
	84	static char buf[17];
	85	char *bp = buf + 16;
	86	*bp = 0;
	87	while (b)
	88	{
	89	*--bp = (v & 1) ? '1' : '0';
	90	v >>= 1;
	91	b--;
	92	}
	93	return bp;
	94	}
	95
	96	static const char *the_bits = 0;
	97
	98	void
	99	decode_indirect (int si, int di)
	100	{
	101	src_indirect = si;
	102	dest_indirect = di;
	103	if (trace && (si \|\| di))
	104	printf ("indirect: s:%d d:%d\n", si, di);
	105	}
	106
	107	void
	108	decode_index (int sa, int da)
	109	{
	110	src_addend = sa;
	111	dest_addend = da;
	112	if (trace && (sa \|\| da))
	113	printf ("index: s:%d d:%d\n", sa, da);
	114	}
	115
	116	srcdest
	117	decode_srcdest4 (int destcode, int bw)
	118	{
	119	srcdest sd;
d45a4bef JB	120	static const char *dc_wnames[16] = { "r0", "r1", "r2", "r3",
	121	"a0", "a1", "[a0]", "[a1]",
	122	"disp8[a0]", "disp8[a1]", "disp8[sb]", "disp8[fb]",
	123	"disp16[a0]", "disp16[a1]", "disp16[sb]", "disp16"
	124	};
	125	static const char *dc_bnames[4] = { "r0l", "r0h", "r1l", "r1h" };;
	126
269e9c18 MF	127	sd.bytes = bw ? 2 : 1;
	128	sd.mem = (destcode >= 6) ? 1 : 0;
	129
d45a4bef JB	130	if (trace)
	131	{
	132	const char *n = dc_wnames[destcode];
	133	if (bw == 0 && destcode <= 3)
	134	n = dc_bnames[destcode];
	135	if (!the_bits)
	136	the_bits = bits (destcode, 4);
	137	printf ("decode: %s (%d) : %s\n", the_bits, destcode, n);
	138	the_bits = 0;
	139	}
	140
	141	switch (destcode)
	142	{
	143	case 0x0:
	144	sd.u.reg = bw ? r0 : r0l;
	145	break;
	146	case 0x1:
	147	sd.u.reg = bw ? r1 : r0h;
	148	break;
	149	case 0x2:
	150	sd.u.reg = bw ? r2 : r1l;
	151	break;
	152	case 0x3:
	153	sd.u.reg = bw ? r3 : r1h;
	154	break;
	155	case 0x4:
	156	sd.u.reg = a0;
	157	break;
	158	case 0x5:
	159	sd.u.reg = a1;
	160	break;
	161	case 0x6:
	162	sd.u.addr = get_reg (a0);
	163	break;
	164	case 0x7:
	165	sd.u.addr = get_reg (a1);
	166	break;
	167	case 0x8:
	168	sd.u.addr = get_reg (a0) + disp8 ();
	169	break;
	170	case 0x9:
	171	sd.u.addr = get_reg (a1) + disp8 ();
	172	break;
	173	case 0xa:
	174	sd.u.addr = get_reg (sb) + disp8 ();
	175	break;
	176	case 0xb:
	177	sd.u.addr = get_reg (fb) + sign_ext (disp8 (), 8);
	178	break;
	179	case 0xc:
	180	sd.u.addr = get_reg (a0) + disp16 ();
	181	break;
	182	case 0xd:
	183	sd.u.addr = get_reg (a1) + disp16 ();
	184	break;
	185	case 0xe:
	186	sd.u.addr = get_reg (sb) + disp16 ();
	187	break;
	188	case 0xf:
	189	sd.u.addr = disp16 ();
	190	break;
	191	default:
	192	abort ();
	193	}
194	if (sd.mem)
195	sd.u.addr &= addr_mask;
196	return sd;
197	}
198
199	srcdest
200	decode_jumpdest (int destcode, int w)
201	{
202	srcdest sd;
d45a4bef JB	203	static const char *dc_wnames[16] = { "r0", "r1", "r2", "r3",
	204	"a0", "a1", "[a0]", "[a1]",
	205	"disp8[a0]", "disp8[a1]", "disp8[sb]", "disp8[fb]",
	206	"disp20[a0]", "disp20[a1]", "disp16[sb]", "abs16"
	207	};
	208	static const char *dc_anames[4] = { "r0l", "r0h", "r1l", "r1h" };
	209
269e9c18 MF	210	sd.bytes = w ? 2 : 3;
	211	sd.mem = (destcode >= 6) ? 1 : 0;
	212
d45a4bef JB	213	if (trace)
	214	{
	215	const char *n = dc_wnames[destcode];
	216	if (w == 0 && destcode <= 3)
	217	n = dc_anames[destcode];
	218	if (!the_bits)
	219	the_bits = bits (destcode, 4);
	220	printf ("decode: %s : %s\n", the_bits, n);
	221	the_bits = 0;
	222	}
	223
	224	switch (destcode)
	225	{
	226	case 0x0:
	227	sd.u.reg = w ? r0 : r2r0;
	228	break;
	229	case 0x1:
	230	sd.u.reg = w ? r1 : r2r0;
	231	break;
	232	case 0x2:
	233	sd.u.reg = w ? r2 : r3r1;
	234	break;
	235	case 0x3:
	236	sd.u.reg = w ? r3 : r3r1;
	237	break;
	238	case 0x4:
	239	sd.u.reg = w ? a0 : a1a0;
	240	break;
	241	case 0x5:
	242	sd.u.reg = w ? a1 : a1a0;
	243	break;
	244	case 0x6:
	245	sd.u.addr = get_reg (a0);
	246	break;
	247	case 0x7:
	248	sd.u.addr = get_reg (a1);
	249	break;
	250	case 0x8:
	251	sd.u.addr = get_reg (a0) + disp8 ();
	252	break;
	253	case 0x9:
	254	sd.u.addr = get_reg (a1) + disp8 ();
	255	break;
	256	case 0xa:
	257	sd.u.addr = get_reg (sb) + disp8 ();
	258	break;
	259	case 0xb:
	260	sd.u.addr = get_reg (fb) + sign_ext (disp8 (), 8);
	261	break;
	262	case 0xc:
	263	sd.u.addr = get_reg (a0) + disp20 ();
	264	break;
	265	case 0xd:
	266	sd.u.addr = get_reg (a1) + disp20 ();
	267	break;
	268	case 0xe:
	269	sd.u.addr = get_reg (sb) + disp16 ();
	270	break;
	271	case 0xf:
	272	sd.u.addr = disp16 ();
	273	break;
	274	default:
	275	abort ();
	276	}
277	if (sd.mem)
278	sd.u.addr &= addr_mask;
279	return sd;
280	}
281
282	srcdest
283	decode_dest3 (int destcode, int bw)
284	{
285	static char map[8] = { -1, -1, -1, 1, 0, 10, 11, 15 };
286
287	the_bits = bits (destcode, 3);
288	return decode_srcdest4 (map[destcode], bw);
289	}
290
291	srcdest
292	decode_src2 (int srccode, int bw, int d)
293	{
294	static char map[4] = { 0, 10, 11, 15 };
295
296	the_bits = bits (srccode, 2);
297	return decode_srcdest4 (srccode ? map[srccode] : 1 - d, bw);
298	}
299
300	static struct
301	{
302	reg_id b_regno;
303	reg_id w_regno;
304	int is_memory;
305	int disp_bytes;
306	char *name;
307	} modes23[] =
308	{
309	{
310	a0, a0, 1, 0, "[A0]"}, /* 0 0 0 0 0 */
311	{
312	a1, a1, 1, 0, "[A1]"}, /* 0 0 0 0 1 */
313	{
314	a0, a0, 0, 0, "A0"}, /* 0 0 0 1 0 */
315	{
316	a1, a1, 0, 0, "A1"}, /* 0 0 0 1 1 */
317	{
318	a0, a0, 1, 1, "dsp:8[A0]"}, /* 0 0 1 0 0 */
319	{
320	a1, a1, 1, 1, "dsp:8[A1]"}, /* 0 0 1 0 1 */
321	{
322	sb, sb, 1, 1, "dsp:8[SB]"}, /* 0 0 1 1 0 */
323	{
324	fb, fb, 1, -1, "dsp:8[FB]"}, /* 0 0 1 1 1 */
325	{
326	a0, a0, 1, 2, "dsp:16[A0]"}, /* 0 1 0 0 0 */
327	{
328	a1, a1, 1, 2, "dsp:16[A1]"}, /* 0 1 0 0 1 */
329	{
330	sb, sb, 1, 2, "dsp:16[SB]"}, /* 0 1 0 1 0 */
331	{
332	fb, fb, 1, -2, "dsp:16[FB]"}, /* 0 1 0 1 1 */
333	{
334	a0, a0, 1, 3, "dsp:24[A0]"}, /* 0 1 1 0 0 */
335	{
336	a1, a1, 1, 3, "dsp:24[A1]"}, /* 0 1 1 0 1 */
337	{
338	mem, mem, 1, 3, "abs24"}, /* 0 1 1 1 0 */
339	{
340	mem, mem, 1, 2, "abs16"}, /* 0 1 1 1 1 */
341	{
342	r0h, r2, 0, 0, "R0H/R2"}, /* 1 0 0 0 0 */
343	{
344	r1h, r3, 0, 0, "R1H/R3"}, /* 1 0 0 0 1 */
345	{
346	r0l, r0, 0, 0, "R0L/R0"}, /* 1 0 0 1 0 */
347	{
348	r1l, r1, 0, 0, "R1L/R1"}, /* 1 0 0 1 1 */
349	};
350
351	static srcdest
352	decode_sd23 (int bbb, int bb, int bytes, int ind, int add)
353	{
354	srcdest sd;
355	int code = (bbb << 2) \| bb;
356
357	if (code >= sizeof (modes23) / sizeof (modes23[0]))
358	abort ();
359
360	if (trace)
361	{
362	char *b1 = "";
363	char *b2 = "";
364	char ad[30];
365	if (ind)
366	{
367	b1 = "[";
368	b2 = "]";
369	}
370	if (add)
371	sprintf (ad, "%+d", add);
372	else
373	ad[0] = 0;
374	if (!the_bits)
375	the_bits = bits (code, 4);
376	printf ("decode: %s (%d) : %s%s%s%s\n", the_bits, code, b1,
377	modes23[code].name, ad, b2);
378	the_bits = 0;
379	}
380
381	sd.bytes = bytes;
382	sd.mem = modes23[code].is_memory;
383	if (sd.mem)
384	{
385	if (modes23[code].w_regno == mem)
386	sd.u.addr = 0;
387	else
388	sd.u.addr = get_reg (modes23[code].w_regno);
389	switch (modes23[code].disp_bytes)
390	{
391	case 1:
392	sd.u.addr += disp8 ();
393	break;
394	case 2:
395	sd.u.addr += disp16 ();
396	break;
397	case -1:
398	sd.u.addr += sign_ext (disp8 (), 8);
399	break;
400	case -2:
401	sd.u.addr += sign_ext (disp16 (), 16);
402	break;
403	case 3:
404	sd.u.addr += disp24 ();
405	break;
406	default:
407	break;
408	}
409	if (add)
410	sd.u.addr += add;
411	if (ind)
412	sd.u.addr = mem_get_si (sd.u.addr & membus_mask);
413	sd.u.addr &= membus_mask;
414	}
415	else
416	{
417	sd.u.reg = (bytes > 1) ? modes23[code].w_regno : modes23[code].b_regno;
418	if (bytes == 3 \|\| bytes == 4)
419	{
420	switch (sd.u.reg)
421	{
422	case r0:
423	sd.u.reg = r2r0;
424	break;
425	case r1:
426	sd.u.reg = r3r1;
427	break;
428	case r2:
429	abort ();
430	case r3:
431	abort ();
432	default:;
433	}
434	}
435
436	}
437	return sd;
438	}
439
440	srcdest
441	decode_dest23 (int ddd, int dd, int bytes)
442	{
443	return decode_sd23 (ddd, dd, bytes, dest_indirect, dest_addend);
444	}
445
446	srcdest
447	decode_src23 (int sss, int ss, int bytes)
448	{
449	return decode_sd23 (sss, ss, bytes, src_indirect, src_addend);
450	}
451
452	srcdest
453	decode_dest2 (int dd, int bytes)
454	{
455	/* r0l/r0, abs16, dsp:8[SB], dsp:8[FB] */
456	static char map[4] = { 0x12, 0x0f, 0x06, 0x07 };
457
458	the_bits = bits (dd, 2);
459	return decode_sd23 (map[dd] >> 2, map[dd] & 3, bytes, dest_indirect,
460	dest_addend);
461	}
462
463	srcdest
464	decode_src3 (int sss, int bytes)
465	{
466	/* r0, r1, a0, a1, r2, r3, N/A, N/A */
467	static char map[8] = { 0x12, 0x13, 0x02, 0x03, 0x10, 0x11, 0, 0 };
468
469	the_bits = bits (sss, 3);
470	return decode_sd23 (map[sss] >> 2, map[sss] & 3, bytes, src_indirect,
471	src_addend);
472	}
473
474	srcdest
475	decode_dest1 (int destcode, int bw)
476	{
477	the_bits = bits (destcode, 1);
478	return decode_srcdest4 (destcode, bw);
479	}
480
481	srcdest
482	decode_cr (int crcode)
483	{
484	static int regcode[] = { 0, intbl, intbh, flags, isp, sp, sb, fb };
485	srcdest sd;
486	sd.mem = 0;
487	sd.bytes = 2;
488	sd.u.reg = regcode[crcode & 7];
489	return sd;
490	}
491
492	srcdest
493	decode_cr_b (int crcode, int bank)
494	{
495	/* FIXME: intbl, intbh, isp */
496	static int regcode[3][8] = {
497	{0, 0, flags, 0, 0, 0, 0, 0},
498	{intb, sp, sb, fb, 0, 0, 0, isp},
499	{0, 0, 0, 0, 0, 0, 0, 0}
500	};
501	srcdest sd;
502	sd.mem = 0;
503	sd.bytes = bank ? 3 : 2;
504	sd.u.reg = regcode[bank][crcode & 7];
505	return sd;
506	}
507
508	srcdest
509	widen_sd (srcdest sd)
510	{
511	sd.bytes *= 2;
512	if (!sd.mem)
513	switch (sd.u.reg)
514	{
515	case r0l:
516	sd.u.reg = r0;
517	break;
518	case r0:
519	sd.u.reg = r2r0;
520	break;
521	case r1l:
522	sd.u.reg = r1;
523	break;
524	case r1:
525	sd.u.reg = r3r1;
526	break;
527	case a0:
528	if (A16)
529	sd.u.reg = a1a0;
530	break;
531	default:
532	break;
533	}
534	return sd;
535	}
536
537	srcdest
538	reg_sd (reg_id reg)
539	{
540	srcdest rv;
541	rv.bytes = reg_bytes[reg];
542	rv.mem = 0;
543	rv.u.reg = reg;
544	return rv;
545	}
546
547	int
548	get_src (srcdest sd)
549	{
550	int v;
551	if (sd.mem)
552	{
553	switch (sd.bytes)
554	{
555	case 1:
556	v = mem_get_qi (sd.u.addr);
557	break;
558	case 2:
559	v = mem_get_hi (sd.u.addr);
560	break;
561	case 3:
562	v = mem_get_psi (sd.u.addr);
563	break;
564	case 4:
565	v = mem_get_si (sd.u.addr);
566	break;
567	default:
568	abort ();
569	}
570	}
571	else
572	{
573	v = get_reg (sd.u.reg);
574	switch (sd.bytes)
575	{
576	case 1:
577	v &= 0xff;
578	break;
579	case 2:
580	v &= 0xffff;
581	break;
582	case 3:
583	v &= 0xffffff;
584	break;
585	}
586	}
587	return v;
588	}
589
590	void
591	put_dest (srcdest sd, int v)
592	{
593	if (sd.mem)
594	{
595	switch (sd.bytes)
596	{
597	case 1:
598	mem_put_qi (sd.u.addr, v);
599	break;
600	case 2:
601	mem_put_hi (sd.u.addr, v);
602	break;
603	case 3:
604	mem_put_psi (sd.u.addr, v);
605	break;
606	case 4:
607	mem_put_si (sd.u.addr, v);
608	break;
609	}
610	}
611	else
612	{
613	switch (sd.bytes)
614	{
615	case 1:
616	v &= 0xff;
617	break;
618	case 2:
619	v &= 0xffff;
620	break;
621	case 3:
622	v &= 0xffffff;
623	break;
624	}
625	put_reg (sd.u.reg, v);
626	}
627	}
628
629	srcdest
630	decode_bit (int destcode)
631	{
632	srcdest sd;
633	int addr = 0;
634	static const char *dc_names[] = { "r0", "r1", "r2", "r3",
635	"a0", "a1", "[a0]", "[a1]",
636	"disp8[a0]", "disp8[a1]", "disp8[sb]", "disp8[fb]",
637	"disp16[a0]", "disp16[a1]", "disp16[sb]", "abs16"
638	};
639
640	if (trace)
641	{
642	const char *the_bits = bits (destcode, 4);
643	printf ("decode: %s : %s\n", the_bits, dc_names[destcode]);
644	}
645
646	switch (destcode)
647	{
648	case 0:
649	sd.u.reg = r0;
650	break;
651	case 1:
652	sd.u.reg = r1;
653	break;
654	case 2:
655	sd.u.reg = r2;
656	break;
657	case 3:
658	sd.u.reg = r3;
659	break;
660	case 4:
661	sd.u.reg = a0;
662	break;
663	case 5:
664	sd.u.reg = a1;
665	break;
666	case 6:
667	addr = get_reg (a0);
668	break;
669	case 7:
670	addr = get_reg (a1);
671	break;
672	case 8:
673	addr = get_reg (a0) + disp8 ();
674	break;
675	case 9:
676	addr = get_reg (a1) + disp8 ();
677	break;
678	case 10:
679	addr = get_reg (sb) * 8 + disp8 ();
680	break;
681	case 11:
682	addr = get_reg (fb) * 8 + sign_ext (disp8 (), 8);
683	break;
684	case 12:
685	addr = get_reg (a0) + disp16 ();
686	break;
687	case 13:
688	addr = get_reg (a1) + disp16 ();
689	break;
690	case 14:
691	addr = get_reg (sb) + disp16 ();
692	break;
693	case 15:
694	addr = disp16 ();
695	break;
696	}
697
698	if (destcode < 6)
699	{
700	int d = disp8 ();
701	sd.mem = 0;
702	sd.mask = 1 << (d & 0x0f);
703	}
704	else
705	{
706	addr &= addr_mask;
707	sd.mem = 1;
708	sd.mask = 1 << (addr & 7);
709	sd.u.addr = addr >> 3;
710	}
711	return sd;
712	}
713
714	srcdest
715	decode_bit11 (int op0)
716	{
717	srcdest sd;
718	sd.mask = 1 << (op0 & 7);
719	sd.mem = 1;
720	sd.u.addr = get_reg (sb) + disp8 ();
721	return sd;
722	}
723
724	int
725	get_bit (srcdest sd)
726	{
727	int b;
728	if (sd.mem)
729	b = mem_get_qi (sd.u.addr) & sd.mask;
730	else
731	b = get_reg (sd.u.reg) & sd.mask;
732	return b ? 1 : 0;
733	}
734
735	void
736	put_bit (srcdest sd, int val)
737	{
738	int b;
739	if (sd.mem)
740	b = mem_get_qi (sd.u.addr);
741	else
742	b = get_reg (sd.u.reg);
743	if (val)
744	b \|= sd.mask;
745	else
746	b &= ~sd.mask;
747	if (sd.mem)
748	mem_put_qi (sd.u.addr, b);
749	else
750	put_reg (sd.u.reg, b);
751	}
752
753	int
754	get_bit2 (srcdest sd, int bit)
755	{
756	int b;
757	if (sd.mem)
758	b = mem_get_qi (sd.u.addr + (bit >> 3)) & (1 << (bit & 7));
759	else
760	b = get_reg (sd.u.reg) & (1 << bit);
761	return b ? 1 : 0;
762	}
763
764	void
765	put_bit2 (srcdest sd, int bit, int val)
766	{
767	int b;
768	if (sd.mem)
769	b = mem_get_qi (sd.u.addr + (bit >> 3));
770	else
771	b = get_reg (sd.u.reg);
772	if (val)
773	b \|= (1 << (bit & 7));
774	else
775	b &= ~(1 << (bit & 7));
776	if (sd.mem)
777	mem_put_qi (sd.u.addr + (bit >> 3), b);
778	else
779	put_reg (sd.u.reg, b);
780	}