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

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

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