sim/m32c/reg.c - binutils-gdb - Git at Google

 /* reg.c --- register set model for M32C simulator.

 Copyright (C) 2005-2021 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/>.  */

 /* This must come before any other includes.  */
 #include "defs.h"

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

 #include "cpu.h"

 int verbose = 0;
 int trace = 0;
 int enable_counting = 0;
 int in_gdb = 1;

 regs_type regs;
 int addr_mask = 0xffff;
 int membus_mask = 0xfffff;
 int m32c_cpu = 0;
 int step_result;
 unsigned int heapbottom = 0;
 unsigned int heaptop = 0;

 char *reg_names[] = {
   "mem",
   "r0", "r0h", "r0l",
   "r1", "r1h", "r1l",
   "r2", "r2r0",
   "r3", "r3r1",
   "r3r1r2r0",
   "r3r2r1r0",
   "a0",
   "a1", "a1a0",
   "sb", "fb",
   "intb", "intbl", "intbh",
   "sp", "usp", "isp", "pc", "flags"
 };

 int reg_bytes[] = {
   0,
   2, 1, 1,
   2, 1, 1,
   2, 4,
   2, 4,
   8,
   8,
   2,
   2, 4,
   2, 2,
   2, 1, 3,
   2, 2, 2, 3, 2
 };


 unsigned int b2mask[] = { 0, 0xff, 0xffff, 0xffffff, 0xffffffff };
 unsigned int b2signbit[] = { 0, (1 << 7), (1 << 15), (1 << 24), (1 << 31) };
 int b2maxsigned[] = { 0, 0x7f, 0x7fff, 0x7fffff, 0x7fffffff };
 int b2minsigned[] = { 0, -128, -32768, -8388608, -2147483647 - 1 };

 static regs_type oldregs;

 int m32c_opcode_pc;

 void
 init_regs (void)
 {
   memset (&regs, 0, sizeof (regs));
   memset (&oldregs, 0, sizeof (oldregs));
 }

 void
 set_pointer_width (int bytes)
 {
   if (bytes == 2)
     {
       addr_mask = 0xffff;
       membus_mask = 0x000fffff;
       reg_bytes[a0] = reg_bytes[a1] = reg_bytes[sb] = reg_bytes[fb] =
 	reg_bytes[sp] = reg_bytes[usp] = reg_bytes[isp] = 2;
     }
   else
     {
       addr_mask = 0xffffff;
       membus_mask = 0x00ffffff;
       reg_bytes[a0] = reg_bytes[a1] = reg_bytes[sb] = reg_bytes[fb] =
 	reg_bytes[sp] = reg_bytes[usp] = reg_bytes[isp] = 3;
     }
 }

 void
 m32c_set_cpu (int cpu)
 {
   switch (cpu)
     {
     case CPU_R8C:
     case CPU_M16C:
       set_pointer_width (2);
       decode_opcode = decode_r8c;
       break;
     case CPU_M32CM:
     case CPU_M32C:
       set_pointer_width (3);
       decode_opcode = decode_m32c;
       break;
     default:
       abort ();
     }
   m32c_cpu = cpu;
 }

 static unsigned int
 get_reg_i (reg_id id)
 {
   reg_bank_type *b = regs.r + (FLAG_B ? 1 : 0);

   switch (id)
     {
     case r0:
       return b->r_r0;
     case r0h:
       return b->r_r0 >> 8;
     case r0l:
       return b->r_r0 & 0xff;
     case r1:
       return b->r_r1;
     case r1h:
       return b->r_r1 >> 8;
     case r1l:
       return b->r_r1 & 0xff;
     case r2:
       return b->r_r2;
     case r2r0:
       return b->r_r2 * 65536 + b->r_r0;
     case r3:
       return b->r_r3;
     case r3r1:
       return b->r_r3 * 65536 + b->r_r1;

     case a0:
       return b->r_a0 & addr_mask;
     case a1:
       return b->r_a1 & addr_mask;
     case a1a0:
       return (b->r_a1 & 0xffff) * 65536 | (b->r_a0 & 0xffff);

     case sb:
       return b->r_sb & addr_mask;
     case fb:
       return b->r_fb & addr_mask;

     case intb:
       return regs.r_intbh * 65536 + regs.r_intbl;
     case intbl:
       return regs.r_intbl;
     case intbh:
       return regs.r_intbh;

     case sp:
       return ((regs.r_flags & FLAGBIT_U) ? regs.r_usp : regs.
 	      r_isp) & addr_mask;
     case usp:
       return regs.r_usp & addr_mask;
     case isp:
       return regs.r_isp & addr_mask;

     case pc:
       return regs.r_pc & membus_mask;
     case flags:
       return regs.r_flags;
     default:
       abort ();
     }
 }

 unsigned int
 get_reg (reg_id id)
 {
   unsigned int rv = get_reg_i (id);
   if (trace > ((id != pc && id != fb && id != sp) ? 0 : 1))
     printf ("get_reg (%s) = %0*x\n", reg_names[id], reg_bytes[id] * 2, rv);
   return rv;
 }

 DI
 get_reg_ll (reg_id id)
 {
   reg_bank_type *b = regs.r + (FLAG_B ? 1 : 0);

   switch (id)
     {
     case r3r1r2r0:
       return ((DI) b->r_r3 << 48
 	      | (DI) b->r_r1 << 32 | (DI) b->r_r2 << 16 | (DI) b->r_r0);
     case r3r2r1r0:
       return ((DI) b->r_r3 << 48
 	      | (DI) b->r_r2 << 32 | (DI) b->r_r1 << 16 | (DI) b->r_r0);
     default:
       return get_reg (id);
     }
 }

 static int highest_sp = 0, lowest_sp = 0xffffff;

 void
 stack_heap_stats (void)
 {
   printf ("heap:  %08x - %08x (%d bytes)\n", heapbottom, heaptop,
 	  heaptop - heapbottom);
   printf ("stack: %08x - %08x (%d bytes)\n", lowest_sp, highest_sp,
 	  highest_sp - lowest_sp);
 }

 void
 put_reg (reg_id id, unsigned int v)
 {
   reg_bank_type *b = regs.r + (FLAG_B ? 1 : 0);

   if (trace > ((id != pc) ? 0 : 1))
     printf ("put_reg (%s) = %0*x\n", reg_names[id], reg_bytes[id] * 2, v);

   switch (id)
     {
     case r0:
       b->r_r0 = v;
       break;
     case r0h:
       b->r_r0 = (b->r_r0 & 0xff) | (v << 8);
       break;
     case r0l:
       b->r_r0 = (b->r_r0 & 0xff00) | (v & 0xff);
       break;
     case r1:
       b->r_r1 = v;
       break;
     case r1h:
       b->r_r1 = (b->r_r1 & 0xff) | (v << 8);
       break;
     case r1l:
       b->r_r1 = (b->r_r1 & 0xff00) | (v & 0xff);
       break;
     case r2:
       b->r_r2 = v;
       break;
     case r2r0:
       b->r_r0 = v & 0xffff;
       b->r_r2 = v >> 16;
       break;
     case r3:
       b->r_r3 = v;
       break;
     case r3r1:
       b->r_r1 = v & 0xffff;
       b->r_r3 = v >> 16;
       break;

     case a0:
       b->r_a0 = v & addr_mask;
       break;
     case a1:
       b->r_a1 = v & addr_mask;
       break;
     case a1a0:
       b->r_a0 = v & 0xffff;
       b->r_a1 = v >> 16;
       break;

     case sb:
       b->r_sb = v & addr_mask;
       break;
     case fb:
       b->r_fb = v & addr_mask;
       break;

     case intb:
       regs.r_intbl = v & 0xffff;
       regs.r_intbh = v >> 16;
       break;
     case intbl:
       regs.r_intbl = v & 0xffff;
       break;
     case intbh:
       regs.r_intbh = v & 0xff;
       break;

     case sp:
       {
 	SI *spp;
 	if (regs.r_flags & FLAGBIT_U)
 	  spp = &regs.r_usp;
 	else
 	  spp = &regs.r_isp;
 	*spp = v & addr_mask;
 	if (*spp < heaptop)
 	  {
 	    printf ("collision: pc %08lx heap %08x stack %08lx\n", regs.r_pc,
 		    heaptop, *spp);
 	    exit (1);
 	  }
 	if (*spp < lowest_sp)
 	  lowest_sp = *spp;
 	if (*spp > highest_sp)
 	  highest_sp = *spp;
 	break;
       }
     case usp:
       regs.r_usp = v & addr_mask;
       break;
     case isp:
       regs.r_isp = v & addr_mask;
       break;

     case pc:
       regs.r_pc = v & membus_mask;
       break;
     case flags:
       regs.r_flags = v;
       break;
     default:
       abort ();
     }
 }

 int
 condition_true (int cond_id)
 {
   int f;
   if (A16)
     {
       static const char *cond_name[] = {
 	"C", "C&!Z", "Z", "S",
 	"!C", "!(C&!Z)", "!Z", "!S",
 	"(S^O)|Z", "O", "!(S^O)", "unk",
 	"!((S^O)|Z)", "!O", "S^O", "unk"
       };
       switch (cond_id & 15)
 	{
 	case 0:
 	  f = FLAG_C;
 	  break;		/* GEU/C */
 	case 1:
 	  f = FLAG_C & !FLAG_Z;
 	  break;		/* GTU */
 	case 2:
 	  f = FLAG_Z;
 	  break;		/* EQ/Z */
 	case 3:
 	  f = FLAG_S;
 	  break;		/* N */
 	case 4:
 	  f = !FLAG_C;
 	  break;		/* LTU/NC */
 	case 5:
 	  f = !(FLAG_C & !FLAG_Z);
 	  break;		/* LEU */
 	case 6:
 	  f = !FLAG_Z;
 	  break;		/* NE/NZ */
 	case 7:
 	  f = !FLAG_S;
 	  break;		/* PZ */

 	case 8:
 	  f = (FLAG_S ^ FLAG_O) | FLAG_Z;
 	  break;		/* LE */
 	case 9:
 	  f = FLAG_O;
 	  break;		/* O */
 	case 10:
 	  f = !(FLAG_S ^ FLAG_O);
 	  break;		/* GE */
 	case 12:
 	  f = !((FLAG_S ^ FLAG_O) | FLAG_Z);
 	  break;		/* GT */
 	case 13:
 	  f = !FLAG_O;
 	  break;		/* NO */
 	case 14:
 	  f = FLAG_S ^ FLAG_O;
 	  break;		/* LT */

 	default:
 	  f = 0;
 	  break;
 	}
       if (trace)
 	printf ("cond[%d] %s = %s\n", cond_id, cond_name[cond_id & 15],
 		f ? "true" : "false");
     }
   else
     {
       static const char *cond_name[] = {
 	"!C", "LEU", "!Z", "PZ",
 	"!O", "GT", "GE", "?",
 	"C", "GTU", "Z", "N",
 	"O", "LE", "LT", "!?"
       };
       switch (cond_id & 15)
 	{
 	case 0:
 	  f = !FLAG_C;
 	  break;		/* LTU/NC */
 	case 1:
 	  f = !(FLAG_C & !FLAG_Z);
 	  break;		/* LEU */
 	case 2:
 	  f = !FLAG_Z;
 	  break;		/* NE/NZ */
 	case 3:
 	  f = !FLAG_S;
 	  break;		/* PZ */

 	case 4:
 	  f = !FLAG_O;
 	  break;		/* NO */
 	case 5:
 	  f = !((FLAG_S ^ FLAG_O) | FLAG_Z);
 	  break;		/* GT */
 	case 6:
 	  f = !(FLAG_S ^ FLAG_O);
 	  break;		/* GE */

 	case 8:
 	  f = FLAG_C;
 	  break;		/* GEU/C */
 	case 9:
 	  f = FLAG_C & !FLAG_Z;
 	  break;		/* GTU */
 	case 10:
 	  f = FLAG_Z;
 	  break;		/* EQ/Z */
 	case 11:
 	  f = FLAG_S;
 	  break;		/* N */

 	case 12:
 	  f = FLAG_O;
 	  break;		/* O */
 	case 13:
 	  f = (FLAG_S ^ FLAG_O) | FLAG_Z;
 	  break;		/* LE */
 	case 14:
 	  f = FLAG_S ^ FLAG_O;
 	  break;		/* LT */

 	default:
 	  f = 0;
 	  break;
 	}
       if (trace)
 	printf ("cond[%d] %s = %s\n", cond_id, cond_name[cond_id & 15],
 		f ? "true" : "false");
     }
   return f;
 }

 void
 set_flags (int mask, int newbits)
 {
   int i;
   regs.r_flags &= ~mask;
   regs.r_flags |= newbits & mask;
   if (trace)
     {
       printf ("flags now \033[32m %d", (regs.r_flags >> (A16 ? 8 : 12)) & 7);
       for (i = 7; i >= 0; i--)
 	if (regs.r_flags & (1 << i))
 	  putchar ("CDZSBOIU"[i]);
 	else
 	  putchar ('-');
       printf ("\033[0m\n");
     }
 }

 void
 set_oszc (int value, int b, int c)
 {
   int mask = b2mask[b];
   int f = 0;

   if (c)
     f |= FLAGBIT_C;
   if ((value & mask) == 0)
     f |= FLAGBIT_Z;
   if (value & b2signbit[b])
     f |= FLAGBIT_S;
   if ((value > b2maxsigned[b]) || (value < b2minsigned[b]))
     f |= FLAGBIT_O;
   set_flags (FLAGBIT_Z | FLAGBIT_S | FLAGBIT_O | FLAGBIT_C, f);
 }

 void
 set_szc (int value, int b, int c)
 {
   int mask = b2mask[b];
   int f = 0;

   if (c)
     f |= FLAGBIT_C;
   if ((value & mask) == 0)
     f |= FLAGBIT_Z;
   if (value & b2signbit[b])
     f |= FLAGBIT_S;
   set_flags (FLAGBIT_Z | FLAGBIT_S | FLAGBIT_C, f);
 }

 void
 set_osz (int value, int b)
 {
   int mask = b2mask[b];
   int f = 0;

   if ((value & mask) == 0)
     f |= FLAGBIT_Z;
   if (value & b2signbit[b])
     f |= FLAGBIT_S;
   if (value & ~mask && (value & ~mask) != ~mask)
     f |= FLAGBIT_O;
   set_flags (FLAGBIT_Z | FLAGBIT_S | FLAGBIT_O, f);
 }

 void
 set_sz (int value, int b)
 {
   int mask = b2mask[b];
   int f = 0;

   if ((value & mask) == 0)
     f |= FLAGBIT_Z;
   if (value & b2signbit[b])
     f |= FLAGBIT_S;
   set_flags (FLAGBIT_Z | FLAGBIT_S, f);
 }

 void
 set_zc (int z, int c)
 {
   set_flags (FLAGBIT_C | FLAGBIT_Z,
 	     (c ? FLAGBIT_C : 0) | (z ? FLAGBIT_Z : 0));
 }

 void
 set_c (int c)
 {
   set_flags (FLAGBIT_C, c ? FLAGBIT_C : 0);
 }

 void
 put_reg_ll (reg_id id, DI v)
 {
   reg_bank_type *b = regs.r + (FLAG_B ? 1 : 0);

   switch (id)
     {
     case r3r1r2r0:
       b->r_r3 = v >> 48;
       b->r_r1 = v >> 32;
       b->r_r2 = v >> 16;
       b->r_r0 = v;
       break;
     case r3r2r1r0:
       b->r_r3 = v >> 48;
       b->r_r2 = v >> 32;
       b->r_r1 = v >> 16;
       b->r_r0 = v;
       break;
     default:
       put_reg (id, v);
     }
 }

 static void
 print_flags (int f)
 {
   int i;
   static char fn[] = "CDZSBOIU";
   printf ("%d.", (f >> 12) & 7);
   for (i = 7; i >= 0; i--)
     if (f & (1 << i))
       putchar (fn[i]);
 }

 #define TRC(f,n, id) \
   if (oldregs.f != regs.f) \
     { \
       printf("  %s %0*x:%0*x", n, \
 	     reg_bytes[id]*2, (unsigned int)oldregs.f, \
 	     reg_bytes[id]*2, (unsigned int)regs.f); \
       oldregs.f = regs.f; \
     }

 void
 trace_register_changes (void)
 {
   if (!trace)
     return;
   printf ("\033[36mREGS:");
   TRC (r[0].r_r0, "r0", r0);
   TRC (r[0].r_r1, "r1", r1);
   TRC (r[0].r_r2, "r2", r2);
   TRC (r[0].r_r3, "r3", r3);
   TRC (r[0].r_a0, "a0", a0);
   TRC (r[0].r_a1, "a1", a1);
   TRC (r[0].r_sb, "sb", sb);
   TRC (r[0].r_fb, "fb", fb);
   TRC (r[1].r_r0, "r0'", r0);
   TRC (r[1].r_r1, "r1'", r1);
   TRC (r[1].r_r2, "r2'", r2);
   TRC (r[1].r_r3, "r3'", r3);
   TRC (r[1].r_a0, "a0'", a0);
   TRC (r[1].r_a1, "a1'", a1);
   TRC (r[1].r_sb, "sb'", sb);
   TRC (r[1].r_fb, "fb'", fb);
   TRC (r_intbh, "intbh", intbh);
   TRC (r_intbl, "intbl", intbl);
   TRC (r_usp, "usp", usp);
   TRC (r_isp, "isp", isp);
   TRC (r_pc, "pc", pc);
   if (oldregs.r_flags != regs.r_flags)
     {
       printf ("  flags ");
       print_flags (oldregs.r_flags);
       printf (":");
       print_flags (regs.r_flags);
     }
   printf ("\033[0m\n");
 }

 #define DRC(f, n, id) \
   printf("  %-3s %0*x", n,			       \
 	 reg_bytes[id]*2, (unsigned int)regs.f);       \

 void
 m32c_dump_all_registers (void)
 {
   printf ("\033[36mREGS:");
   DRC (r[0].r_r0, "r0", r0);
   DRC (r[0].r_r1, "r1", r1);
   DRC (r[0].r_r2, "r2", r2);
   DRC (r[0].r_r3, "r3", r3);
   DRC (r[0].r_a0, "a0", a0);
   DRC (r[0].r_a1, "a1", a1);
   DRC (r[0].r_sb, "sb", sb);
   DRC (r[0].r_fb, "fb", fb);
   printf ("\n     ");
   DRC (r[1].r_r0, "r0'", r0);
   DRC (r[1].r_r1, "r1'", r1);
   DRC (r[1].r_r2, "r2'", r2);
   DRC (r[1].r_r3, "r3'", r3);
   DRC (r[1].r_a0, "a0'", a0);
   DRC (r[1].r_a1, "a1'", a1);
   DRC (r[1].r_sb, "sb'", sb);
   DRC (r[1].r_fb, "fb'", fb);
   printf ("     \n");
   DRC (r_intbh, "intbh", intbh);
   DRC (r_intbl, "intbl", intbl);
   DRC (r_usp, "usp", usp);
   DRC (r_isp, "isp", isp);
   DRC (r_pc, "pc", pc);
   printf ("  flags ");
   print_flags (regs.r_flags);
   printf ("\033[0m\n");
   /*sim_disasm_one (); */
 }
	/* reg.c --- register set model for M32C simulator.

	Copyright (C) 2005-2021 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/>. */

	/* This must come before any other includes. */
	#include "defs.h"

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

	#include "cpu.h"

	int verbose = 0;
	int trace = 0;
	int enable_counting = 0;
	int in_gdb = 1;

	regs_type regs;
	int addr_mask = 0xffff;
	int membus_mask = 0xfffff;
	int m32c_cpu = 0;
	int step_result;
	unsigned int heapbottom = 0;
	unsigned int heaptop = 0;

	char *reg_names[] = {
	"mem",
	"r0", "r0h", "r0l",
	"r1", "r1h", "r1l",
	"r2", "r2r0",
	"r3", "r3r1",
	"r3r1r2r0",
	"r3r2r1r0",
	"a0",
	"a1", "a1a0",
	"sb", "fb",
	"intb", "intbl", "intbh",
	"sp", "usp", "isp", "pc", "flags"
	};

	int reg_bytes[] = {
	0,
	2, 1, 1,
	2, 1, 1,
	2, 4,
	2, 4,
	8,
	8,
	2,
	2, 4,
	2, 2,
	2, 1, 3,
	2, 2, 2, 3, 2
	};


	unsigned int b2mask[] = { 0, 0xff, 0xffff, 0xffffff, 0xffffffff };
	unsigned int b2signbit[] = { 0, (1 << 7), (1 << 15), (1 << 24), (1 << 31) };
	int b2maxsigned[] = { 0, 0x7f, 0x7fff, 0x7fffff, 0x7fffffff };
	int b2minsigned[] = { 0, -128, -32768, -8388608, -2147483647 - 1 };

	static regs_type oldregs;

	int m32c_opcode_pc;

	void
	init_regs (void)
	{
	memset (&regs, 0, sizeof (regs));
	memset (&oldregs, 0, sizeof (oldregs));
	}

	void
	set_pointer_width (int bytes)
	{
	if (bytes == 2)
	{
	addr_mask = 0xffff;
	membus_mask = 0x000fffff;
	reg_bytes[a0] = reg_bytes[a1] = reg_bytes[sb] = reg_bytes[fb] =
	reg_bytes[sp] = reg_bytes[usp] = reg_bytes[isp] = 2;
	}
	else
	{
	addr_mask = 0xffffff;
	membus_mask = 0x00ffffff;
	reg_bytes[a0] = reg_bytes[a1] = reg_bytes[sb] = reg_bytes[fb] =
	reg_bytes[sp] = reg_bytes[usp] = reg_bytes[isp] = 3;
	}
	}

	void
	m32c_set_cpu (int cpu)
	{
	switch (cpu)
	{
	case CPU_R8C:
	case CPU_M16C:
	set_pointer_width (2);
	decode_opcode = decode_r8c;
	break;
	case CPU_M32CM:
	case CPU_M32C:
	set_pointer_width (3);
	decode_opcode = decode_m32c;
	break;
	default:
	abort ();
	}
	m32c_cpu = cpu;
	}

	static unsigned int
	get_reg_i (reg_id id)
	{
	reg_bank_type *b = regs.r + (FLAG_B ? 1 : 0);

	switch (id)
	{
	case r0:
	return b->r_r0;
	case r0h:
	return b->r_r0 >> 8;
	case r0l:
	return b->r_r0 & 0xff;
	case r1:
	return b->r_r1;
	case r1h:
	return b->r_r1 >> 8;
	case r1l:
	return b->r_r1 & 0xff;
	case r2:
	return b->r_r2;
	case r2r0:
	return b->r_r2 * 65536 + b->r_r0;
	case r3:
	return b->r_r3;
	case r3r1:
	return b->r_r3 * 65536 + b->r_r1;

	case a0:
	return b->r_a0 & addr_mask;
	case a1:
	return b->r_a1 & addr_mask;
	case a1a0:
	return (b->r_a1 & 0xffff) * 65536 \| (b->r_a0 & 0xffff);

	case sb:
	return b->r_sb & addr_mask;
	case fb:
	return b->r_fb & addr_mask;

	case intb:
	return regs.r_intbh * 65536 + regs.r_intbl;
	case intbl:
	return regs.r_intbl;
	case intbh:
	return regs.r_intbh;

	case sp:
	return ((regs.r_flags & FLAGBIT_U) ? regs.r_usp : regs.
	r_isp) & addr_mask;
	case usp:
	return regs.r_usp & addr_mask;
	case isp:
	return regs.r_isp & addr_mask;

	case pc:
	return regs.r_pc & membus_mask;
	case flags:
	return regs.r_flags;
	default:
	abort ();
	}
	}

	unsigned int
	get_reg (reg_id id)
	{
	unsigned int rv = get_reg_i (id);
	if (trace > ((id != pc && id != fb && id != sp) ? 0 : 1))
	printf ("get_reg (%s) = %0x\n", reg_names[id], reg_bytes[id] 2, rv);
	return rv;
	}

	DI
	get_reg_ll (reg_id id)
	{
	reg_bank_type *b = regs.r + (FLAG_B ? 1 : 0);

	switch (id)
	{
	case r3r1r2r0:
	return ((DI) b->r_r3 << 48
	\| (DI) b->r_r1 << 32 \| (DI) b->r_r2 << 16 \| (DI) b->r_r0);
	case r3r2r1r0:
	return ((DI) b->r_r3 << 48
	\| (DI) b->r_r2 << 32 \| (DI) b->r_r1 << 16 \| (DI) b->r_r0);
	default:
	return get_reg (id);
	}
	}

	static int highest_sp = 0, lowest_sp = 0xffffff;

	void
	stack_heap_stats (void)
	{
	printf ("heap: %08x - %08x (%d bytes)\n", heapbottom, heaptop,
	heaptop - heapbottom);
	printf ("stack: %08x - %08x (%d bytes)\n", lowest_sp, highest_sp,
	highest_sp - lowest_sp);
	}

	void
	put_reg (reg_id id, unsigned int v)
	{
	reg_bank_type *b = regs.r + (FLAG_B ? 1 : 0);

	if (trace > ((id != pc) ? 0 : 1))
	printf ("put_reg (%s) = %0x\n", reg_names[id], reg_bytes[id] 2, v);

	switch (id)
	{
	case r0:
	b->r_r0 = v;
	break;
	case r0h:
	b->r_r0 = (b->r_r0 & 0xff) \| (v << 8);
	break;
	case r0l:
	b->r_r0 = (b->r_r0 & 0xff00) \| (v & 0xff);
	break;
	case r1:
	b->r_r1 = v;
	break;
	case r1h:
	b->r_r1 = (b->r_r1 & 0xff) \| (v << 8);
	break;
	case r1l:
	b->r_r1 = (b->r_r1 & 0xff00) \| (v & 0xff);
	break;
	case r2:
	b->r_r2 = v;
	break;
	case r2r0:
	b->r_r0 = v & 0xffff;
	b->r_r2 = v >> 16;
	break;
	case r3:
	b->r_r3 = v;
	break;
	case r3r1:
	b->r_r1 = v & 0xffff;
	b->r_r3 = v >> 16;
	break;

	case a0:
	b->r_a0 = v & addr_mask;
	break;
	case a1:
	b->r_a1 = v & addr_mask;
	break;
	case a1a0:
	b->r_a0 = v & 0xffff;
	b->r_a1 = v >> 16;
	break;

	case sb:
	b->r_sb = v & addr_mask;
	break;
	case fb:
	b->r_fb = v & addr_mask;
	break;

	case intb:
	regs.r_intbl = v & 0xffff;
	regs.r_intbh = v >> 16;
	break;
	case intbl:
	regs.r_intbl = v & 0xffff;
	break;
	case intbh:
	regs.r_intbh = v & 0xff;
	break;

	case sp:
	{
	SI *spp;
	if (regs.r_flags & FLAGBIT_U)
	spp = &regs.r_usp;
	else
	spp = &regs.r_isp;
	*spp = v & addr_mask;
	if (*spp < heaptop)
	{
	printf ("collision: pc %08lx heap %08x stack %08lx\n", regs.r_pc,
	heaptop, *spp);
	exit (1);
	}
	if (*spp < lowest_sp)
	lowest_sp = *spp;
	if (*spp > highest_sp)
	highest_sp = *spp;
	break;
	}
	case usp:
	regs.r_usp = v & addr_mask;
	break;
	case isp:
	regs.r_isp = v & addr_mask;
	break;

	case pc:
	regs.r_pc = v & membus_mask;
	break;
	case flags:
	regs.r_flags = v;
	break;
	default:
	abort ();
	}
	}

	int
	condition_true (int cond_id)
	{
	int f;
	if (A16)
	{
	static const char *cond_name[] = {
	"C", "C&!Z", "Z", "S",
	"!C", "!(C&!Z)", "!Z", "!S",
	"(S^O)\|Z", "O", "!(S^O)", "unk",
	"!((S^O)\|Z)", "!O", "S^O", "unk"
	};
	switch (cond_id & 15)
	{
	case 0:
	f = FLAG_C;
	break; /* GEU/C */
	case 1:
	f = FLAG_C & !FLAG_Z;
	break; /* GTU */
	case 2:
	f = FLAG_Z;
	break; /* EQ/Z */
	case 3:
	f = FLAG_S;
	break; /* N */
	case 4:
	f = !FLAG_C;
	break; /* LTU/NC */
	case 5:
	f = !(FLAG_C & !FLAG_Z);
	break; /* LEU */
	case 6:
	f = !FLAG_Z;
	break; /* NE/NZ */
	case 7:
	f = !FLAG_S;
	break; /* PZ */

	case 8:
	f = (FLAG_S ^ FLAG_O) \| FLAG_Z;
	break; /* LE */
	case 9:
	f = FLAG_O;
	break; /* O */
	case 10:
	f = !(FLAG_S ^ FLAG_O);
	break; /* GE */
	case 12:
	f = !((FLAG_S ^ FLAG_O) \| FLAG_Z);
	break; /* GT */
	case 13:
	f = !FLAG_O;
	break; /* NO */
	case 14:
	f = FLAG_S ^ FLAG_O;
	break; /* LT */

	default:
	f = 0;
	break;
	}
	if (trace)
	printf ("cond[%d] %s = %s\n", cond_id, cond_name[cond_id & 15],
	f ? "true" : "false");
	}
	else
	{
	static const char *cond_name[] = {
	"!C", "LEU", "!Z", "PZ",
	"!O", "GT", "GE", "?",
	"C", "GTU", "Z", "N",
	"O", "LE", "LT", "!?"
	};
	switch (cond_id & 15)
	{
	case 0:
	f = !FLAG_C;
	break; /* LTU/NC */
	case 1:
	f = !(FLAG_C & !FLAG_Z);
	break; /* LEU */
	case 2:
	f = !FLAG_Z;
	break; /* NE/NZ */
	case 3:
	f = !FLAG_S;
	break; /* PZ */

	case 4:
	f = !FLAG_O;
	break; /* NO */
	case 5:
	f = !((FLAG_S ^ FLAG_O) \| FLAG_Z);
	break; /* GT */
	case 6:
	f = !(FLAG_S ^ FLAG_O);
	break; /* GE */

	case 8:
	f = FLAG_C;
	break; /* GEU/C */
	case 9:
	f = FLAG_C & !FLAG_Z;
	break; /* GTU */
	case 10:
	f = FLAG_Z;
	break; /* EQ/Z */
	case 11:
	f = FLAG_S;
	break; /* N */

	case 12:
	f = FLAG_O;
	break; /* O */
	case 13:
	f = (FLAG_S ^ FLAG_O) \| FLAG_Z;
	break; /* LE */
	case 14:
	f = FLAG_S ^ FLAG_O;
	break; /* LT */

	default:
	f = 0;
	break;
	}
	if (trace)
	printf ("cond[%d] %s = %s\n", cond_id, cond_name[cond_id & 15],
	f ? "true" : "false");
	}
	return f;
	}

	void
	set_flags (int mask, int newbits)
	{
	int i;
	regs.r_flags &= ~mask;
	regs.r_flags \|= newbits & mask;
	if (trace)
	{
	printf ("flags now \033[32m %d", (regs.r_flags >> (A16 ? 8 : 12)) & 7);
	for (i = 7; i >= 0; i--)
	if (regs.r_flags & (1 << i))
	putchar ("CDZSBOIU"[i]);
	else
	putchar ('-');
	printf ("\033[0m\n");
	}
	}

	void
	set_oszc (int value, int b, int c)
	{
	int mask = b2mask[b];
	int f = 0;

	if (c)
	f \|= FLAGBIT_C;
	if ((value & mask) == 0)
	f \|= FLAGBIT_Z;
	if (value & b2signbit[b])
	f \|= FLAGBIT_S;
	if ((value > b2maxsigned[b]) \|\| (value < b2minsigned[b]))
	f \|= FLAGBIT_O;
	set_flags (FLAGBIT_Z \| FLAGBIT_S \| FLAGBIT_O \| FLAGBIT_C, f);
	}

	void
	set_szc (int value, int b, int c)
	{
	int mask = b2mask[b];
	int f = 0;

	if (c)
	f \|= FLAGBIT_C;
	if ((value & mask) == 0)
	f \|= FLAGBIT_Z;
	if (value & b2signbit[b])
	f \|= FLAGBIT_S;
	set_flags (FLAGBIT_Z \| FLAGBIT_S \| FLAGBIT_C, f);
	}

	void
	set_osz (int value, int b)
	{
	int mask = b2mask[b];
	int f = 0;

	if ((value & mask) == 0)
	f \|= FLAGBIT_Z;
	if (value & b2signbit[b])
	f \|= FLAGBIT_S;
	if (value & ~mask && (value & ~mask) != ~mask)
	f \|= FLAGBIT_O;
	set_flags (FLAGBIT_Z \| FLAGBIT_S \| FLAGBIT_O, f);
	}

	void
	set_sz (int value, int b)
	{
	int mask = b2mask[b];
	int f = 0;

	if ((value & mask) == 0)
	f \|= FLAGBIT_Z;
	if (value & b2signbit[b])
	f \|= FLAGBIT_S;
	set_flags (FLAGBIT_Z \| FLAGBIT_S, f);
	}

	void
	set_zc (int z, int c)
	{
	set_flags (FLAGBIT_C \| FLAGBIT_Z,
	(c ? FLAGBIT_C : 0) \| (z ? FLAGBIT_Z : 0));
	}

	void
	set_c (int c)
	{
	set_flags (FLAGBIT_C, c ? FLAGBIT_C : 0);
	}

	void
	put_reg_ll (reg_id id, DI v)
	{
	reg_bank_type *b = regs.r + (FLAG_B ? 1 : 0);

	switch (id)
	{
	case r3r1r2r0:
	b->r_r3 = v >> 48;
	b->r_r1 = v >> 32;
	b->r_r2 = v >> 16;
	b->r_r0 = v;
	break;
	case r3r2r1r0:
	b->r_r3 = v >> 48;
	b->r_r2 = v >> 32;
	b->r_r1 = v >> 16;
	b->r_r0 = v;
	break;
	default:
	put_reg (id, v);
	}
	}

	static void
	print_flags (int f)
	{
	int i;
	static char fn[] = "CDZSBOIU";
	printf ("%d.", (f >> 12) & 7);
	for (i = 7; i >= 0; i--)
	if (f & (1 << i))
	putchar (fn[i]);
	}

	#define TRC(f,n, id) \
	if (oldregs.f != regs.f) \
	{ \
	printf(" %s %0x:%0x", n, \
	reg_bytes[id]*2, (unsigned int)oldregs.f, \
	reg_bytes[id]*2, (unsigned int)regs.f); \
	oldregs.f = regs.f; \
	}

	void
	trace_register_changes (void)
	{
	if (!trace)
	return;
	printf ("\033[36mREGS:");
	TRC (r[0].r_r0, "r0", r0);
	TRC (r[0].r_r1, "r1", r1);
	TRC (r[0].r_r2, "r2", r2);
	TRC (r[0].r_r3, "r3", r3);
	TRC (r[0].r_a0, "a0", a0);
	TRC (r[0].r_a1, "a1", a1);
	TRC (r[0].r_sb, "sb", sb);
	TRC (r[0].r_fb, "fb", fb);
	TRC (r[1].r_r0, "r0'", r0);
	TRC (r[1].r_r1, "r1'", r1);
	TRC (r[1].r_r2, "r2'", r2);
	TRC (r[1].r_r3, "r3'", r3);
	TRC (r[1].r_a0, "a0'", a0);
	TRC (r[1].r_a1, "a1'", a1);
	TRC (r[1].r_sb, "sb'", sb);
	TRC (r[1].r_fb, "fb'", fb);
	TRC (r_intbh, "intbh", intbh);
	TRC (r_intbl, "intbl", intbl);
	TRC (r_usp, "usp", usp);
	TRC (r_isp, "isp", isp);
	TRC (r_pc, "pc", pc);
	if (oldregs.r_flags != regs.r_flags)
	{
	printf (" flags ");
	print_flags (oldregs.r_flags);
	printf (":");
	print_flags (regs.r_flags);
	}
	printf ("\033[0m\n");
	}

	#define DRC(f, n, id) \
	printf(" %-3s %0*x", n, \
	reg_bytes[id]*2, (unsigned int)regs.f); \

	void
	m32c_dump_all_registers (void)
	{
	printf ("\033[36mREGS:");
	DRC (r[0].r_r0, "r0", r0);
	DRC (r[0].r_r1, "r1", r1);
	DRC (r[0].r_r2, "r2", r2);
	DRC (r[0].r_r3, "r3", r3);
	DRC (r[0].r_a0, "a0", a0);
	DRC (r[0].r_a1, "a1", a1);
	DRC (r[0].r_sb, "sb", sb);
	DRC (r[0].r_fb, "fb", fb);
	printf ("\n ");
	DRC (r[1].r_r0, "r0'", r0);
	DRC (r[1].r_r1, "r1'", r1);
	DRC (r[1].r_r2, "r2'", r2);
	DRC (r[1].r_r3, "r3'", r3);
	DRC (r[1].r_a0, "a0'", a0);
	DRC (r[1].r_a1, "a1'", a1);
	DRC (r[1].r_sb, "sb'", sb);
	DRC (r[1].r_fb, "fb'", fb);
	printf (" \n");
	DRC (r_intbh, "intbh", intbh);
	DRC (r_intbl, "intbl", intbl);
	DRC (r_usp, "usp", usp);
	DRC (r_isp, "isp", isp);
	DRC (r_pc, "pc", pc);
	printf (" flags ");
	print_flags (regs.r_flags);
	printf ("\033[0m\n");
	/sim_disasm_one (); /
	}