[thirdparty/binutils-gdb.git] / sim / rx / mem.c

/* mem.c --- memory for RX simulator.

Copyright (C) 2005, 2007, 2008, 2009, 2010 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 slows down the simulator and we get some false negatives from
   gcc, like when it uses a long-sized hole to hold a byte-sized
   variable, knowing that it doesn't care about the other bits.  But,
   if you need to track down a read-from-unitialized bug, set this to
   1.  */
#define RDCHECK 0

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

#include "opcode/rx.h"
#include "mem.h"
#include "cpu.h"
#include "syscalls.h"
#include "misc.h"
#include "err.h"

#define L1_BITS  (10)
#define L2_BITS  (10)
#define OFF_BITS PAGE_BITS

#define L1_LEN  (1 << L1_BITS)
#define L2_LEN  (1 << L2_BITS)
#define OFF_LEN (1 << OFF_BITS)

static unsigned char **pt[L1_LEN];
static unsigned char **ptr[L1_LEN];
static RX_Opcode_Decoded ***ptdc[L1_LEN];

/* [ get=0/put=1 ][ byte size ] */
static unsigned int mem_counters[2][5];

#define COUNT(isput,bytes)                                      \
  if (verbose && enable_counting) mem_counters[isput][bytes]++

void
init_mem (void)
{
  int i, j;

  for (i = 0; i < L1_LEN; i++)
    if (pt[i])
      {
	for (j = 0; j < L2_LEN; j++)
	  if (pt[i][j])
	    free (pt[i][j]);
	free (pt[i]);
      }
  memset (pt, 0, sizeof (pt));
  memset (ptr, 0, sizeof (ptr));
  memset (mem_counters, 0, sizeof (mem_counters));
}

unsigned char *
rx_mem_ptr (unsigned long address, enum mem_ptr_action action)
{
  int pt1 = (address >> (L2_BITS + OFF_BITS)) & ((1 << L1_BITS) - 1);
  int pt2 = (address >> OFF_BITS) & ((1 << L2_BITS) - 1);
  int pto = address & ((1 << OFF_BITS) - 1);

  if (address == 0)
    execution_error (SIM_ERR_NULL_POINTER_DEREFERENCE, 0);

  if (pt[pt1] == 0)
    {
      pt[pt1] = (unsigned char **) calloc (L2_LEN, sizeof (char **));
      ptr[pt1] = (unsigned char **) calloc (L2_LEN, sizeof (char **));
      ptdc[pt1] = (RX_Opcode_Decoded ***) calloc (L2_LEN, sizeof (RX_Opcode_Decoded ***));
    }
  if (pt[pt1][pt2] == 0)
    {
      if (action == MPA_READING)
	execution_error (SIM_ERR_READ_UNWRITTEN_PAGES, address);

      pt[pt1][pt2] = (unsigned char *) calloc (OFF_LEN, 1);
      ptr[pt1][pt2] = (unsigned char *) calloc (OFF_LEN, 1);
      ptdc[pt1][pt2] = (RX_Opcode_Decoded **) calloc (OFF_LEN, sizeof(RX_Opcode_Decoded *));
    }
  else if (action == MPA_READING
	   && ptr[pt1][pt2][pto] == MC_UNINIT)
    execution_error (SIM_ERR_READ_UNWRITTEN_BYTES, address);

  if (action == MPA_WRITING)
    {
      if (ptr[pt1][pt2][pto] == MC_PUSHED_PC)
	execution_error (SIM_ERR_CORRUPT_STACK, address);
      ptr[pt1][pt2][pto] = MC_DATA;
      if (ptdc[pt1][pt2][pto])
	{
	  free (ptdc[pt1][pt2][pto]);
	  ptdc[pt1][pt2][pto] = NULL;
	}
    }

  if (action == MPA_CONTENT_TYPE)
    return (unsigned char *) (ptr[pt1][pt2] + pto);

  if (action == MPA_DECODE_CACHE)
    return (unsigned char *) (ptdc[pt1][pt2] + pto);

  return pt[pt1][pt2] + pto;
}

RX_Opcode_Decoded **
rx_mem_decode_cache (unsigned long address)
{
  return (RX_Opcode_Decoded **) rx_mem_ptr (address, MPA_DECODE_CACHE);
}

static inline int
is_reserved_address (unsigned int address)
{
  return (address >= 0x00020000 && address < 0x00080000)
    ||   (address >= 0x00100000 && address < 0x01000000)
    ||   (address >= 0x08000000 && address < 0xff000000);
}

static void
used (int rstart, int i, int j)
{
  int rend = i << (L2_BITS + OFF_BITS);
  rend += j << OFF_BITS;
  if (rstart == 0xe0000 && rend == 0xe1000)
    return;
  printf ("mem:   %08x - %08x (%dk bytes)\n", rstart, rend - 1,
	  (rend - rstart) / 1024);
}

static char *
mcs (int isput, int bytes)
{
  return comma (mem_counters[isput][bytes]);
}

void
mem_usage_stats ()
{
  int i, j;
  int rstart = 0;
  int pending = 0;

  for (i = 0; i < L1_LEN; i++)
    if (pt[i])
      {
	for (j = 0; j < L2_LEN; j++)
	  if (pt[i][j])
	    {
	      if (!pending)
		{
		  pending = 1;
		  rstart = (i << (L2_BITS + OFF_BITS)) + (j << OFF_BITS);
		}
	    }
	  else if (pending)
	    {
	      pending = 0;
	      used (rstart, i, j);
	    }
      }
    else
      {
	if (pending)
	  {
	    pending = 0;
	    used (rstart, i, 0);
	  }
      }
  /*       mem foo: 123456789012 123456789012 123456789012 123456789012
            123456789012 */
  printf ("                 byte        short        3byte         long"
          "       opcode\n");
  if (verbose > 1)
    {
      /* Only use comma separated numbers when being very verbose.
	 Comma separated numbers are hard to parse in awk scripts.  */
      printf ("mem get: %12s %12s %12s %12s %12s\n", mcs (0, 1), mcs (0, 2),
	      mcs (0, 3), mcs (0, 4), mcs (0, 0));
      printf ("mem put: %12s %12s %12s %12s\n", mcs (1, 1), mcs (1, 2),
	      mcs (1, 3), mcs (1, 4));
    }
  else
    {
      printf ("mem get: %12u %12u %12u %12u %12u\n",
	      mem_counters[0][1], mem_counters[0][2],
	      mem_counters[0][3], mem_counters[0][4],
	      mem_counters[0][0]);
      printf ("mem put: %12u %12u %12u %12u\n",
	      mem_counters [1][1], mem_counters [1][2],
	      mem_counters [1][3], mem_counters [1][4]);
    }
}

unsigned long
mem_usage_cycles (void)
{
  unsigned long rv = mem_counters[0][0];
  rv += mem_counters[0][1] * 1;
  rv += mem_counters[0][2] * 2;
  rv += mem_counters[0][3] * 3;
  rv += mem_counters[0][4] * 4;
  rv += mem_counters[1][1] * 1;
  rv += mem_counters[1][2] * 2;
  rv += mem_counters[1][3] * 3;
  rv += mem_counters[1][4] * 4;
  return rv;
}

static int tpr = 0;
static void
s (int address, char *dir)
{
  if (tpr == 0)
    printf ("MEM[%08x] %s", address, dir);
  tpr++;
}

#define S(d) if (trace) s(address, d)
static void
e ()
{
  if (!trace)
    return;
  tpr--;
  if (tpr == 0)
    printf ("\n");
}

static char
mtypec (int address)
{
  unsigned char *cp = rx_mem_ptr (address, MPA_CONTENT_TYPE);
  return "udp"[*cp];
}

#define E() if (trace) e()

void
mem_put_byte (unsigned int address, unsigned char value)
{
  unsigned char *m;
  char tc = ' ';

  if (trace)
    tc = mtypec (address);
  m = rx_mem_ptr (address, MPA_WRITING);
  if (trace)
    printf (" %02x%c", value, tc);
  *m = value;
  switch (address)
    {
    case 0x0008c02a: /* PA.DR */
     {
	static int old_led = -1;
	int red_on = 0;
	int i;

	if (old_led != value)
	  {
	    fputs (" ", stdout);
	    for (i = 0; i < 8; i++)
	      if (value & (1 << i))
		{
		  if (! red_on)
		    {
		      fputs ("\033[31m", stdout);
		      red_on = 1;
		    }
		  fputs (" @", stdout);
		}
	      else
		{
		  if (red_on)
		    {
		      fputs ("\033[0m", stdout);
		      red_on = 0;
		    }
		  fputs (" *", stdout);
		}

	    if (red_on)
	      fputs ("\033[0m", stdout);

	    fputs ("\r", stdout);
	    fflush (stdout);
	    old_led = value;
	  }
      }
      break;

#ifdef CYCLE_STATS
    case 0x0008c02b: /* PB.DR */
      {
	if (value == 0)
	  halt_pipeline_stats ();
	else
	  reset_pipeline_stats ();
      }
#endif

    case 0x00088263: /* SCI4.TDR */
      {
	static int pending_exit = 0;
	if (pending_exit == 2)
	  {
	    step_result = RX_MAKE_EXITED(value);
	    longjmp (decode_jmp_buf, 1);
	  }
	else if (value == 3)
	  pending_exit ++;
	else
	  pending_exit = 0;

	putchar(value);
      }
      break;

    default:
      if (is_reserved_address (address))
	generate_access_exception ();
    }
}

void
mem_put_qi (int address, unsigned char value)
{
  S ("<=");
  mem_put_byte (address, value & 0xff);
  E ();
  COUNT (1, 1);
}

#ifdef CYCLE_ACCURATE
static int tpu_base;
#endif

void
mem_put_hi (int address, unsigned short value)
{
  S ("<=");
  switch (address)
    {
#ifdef CYCLE_ACCURATE
    case 0x00088126: /* TPU1.TCNT */
      tpu_base = regs.cycle_count;
      break;
    case 0x00088136: /* TPU2.TCNT */
      tpu_base = regs.cycle_count;
      break;
#endif
    default:
      if (rx_big_endian)
	{
	  mem_put_byte (address, value >> 8);
	  mem_put_byte (address + 1, value & 0xff);
	}
      else
	{
	  mem_put_byte (address, value & 0xff);
	  mem_put_byte (address + 1, value >> 8);
	}
    }
  E ();
  COUNT (1, 2);
}

void
mem_put_psi (int address, unsigned long value)
{
  S ("<=");
  if (rx_big_endian)
    {
      mem_put_byte (address, value >> 16);
      mem_put_byte (address + 1, (value >> 8) & 0xff);
      mem_put_byte (address + 2, value & 0xff);
    }
  else
    {
      mem_put_byte (address, value & 0xff);
      mem_put_byte (address + 1, (value >> 8) & 0xff);
      mem_put_byte (address + 2, value >> 16);
    }
  E ();
  COUNT (1, 3);
}

void
mem_put_si (int address, unsigned long value)
{
  S ("<=");
  if (rx_big_endian)
    {
      mem_put_byte (address + 0, (value >> 24) & 0xff);
      mem_put_byte (address + 1, (value >> 16) & 0xff);
      mem_put_byte (address + 2, (value >> 8) & 0xff);
      mem_put_byte (address + 3, value & 0xff);
    }
  else
    {
      mem_put_byte (address + 0, value & 0xff);
      mem_put_byte (address + 1, (value >> 8) & 0xff);
      mem_put_byte (address + 2, (value >> 16) & 0xff);
      mem_put_byte (address + 3, (value >> 24) & 0xff);
    }
  E ();
  COUNT (1, 4);
}

void
mem_put_blk (int address, void *bufptr, int nbytes)
{
  S ("<=");
  if (enable_counting)
    mem_counters[1][1] += nbytes;
  while (nbytes--)
    mem_put_byte (address++, *(unsigned char *) bufptr++);
  E ();
}

unsigned char
mem_get_pc (int address)
{
  unsigned char *m = rx_mem_ptr (address, MPA_READING);
  COUNT (0, 0);
  return *m;
}

static unsigned char
mem_get_byte (unsigned int address)
{
  unsigned char *m;

  S ("=>");
  m = rx_mem_ptr (address, MPA_READING);
  switch (address)
    {
    case 0x00088264: /* SCI4.SSR */
      E();
      return 0x04; /* transmitter empty */
      break;
    default: 
      if (trace)
	printf (" %02x%c", *m, mtypec (address));
      if (is_reserved_address (address))
	generate_access_exception ();
      break;
    }
  E ();
  return *m;
}

unsigned char
mem_get_qi (int address)
{
  unsigned char rv;
  S ("=>");
  rv = mem_get_byte (address);
  COUNT (0, 1);
  E ();
  return rv;
}

unsigned short
mem_get_hi (int address)
{
  unsigned short rv;
  S ("=>");
  switch (address)
    {
#ifdef CYCLE_ACCURATE
    case 0x00088126: /* TPU1.TCNT */
      rv = (regs.cycle_count - tpu_base) >> 16;
      break;
    case 0x00088136: /* TPU2.TCNT */
      rv = (regs.cycle_count - tpu_base) >> 0;
      break;
#endif

    default:
      if (rx_big_endian)
	{
	  rv = mem_get_byte (address) << 8;
	  rv |= mem_get_byte (address + 1);
	}
      else
	{
	  rv = mem_get_byte (address);
	  rv |= mem_get_byte (address + 1) << 8;
	}
    }
  COUNT (0, 2);
  E ();
  return rv;
}

unsigned long
mem_get_psi (int address)
{
  unsigned long rv;
  S ("=>");
  if (rx_big_endian)
    {
      rv = mem_get_byte (address + 2);
      rv |= mem_get_byte (address + 1) << 8;
      rv |= mem_get_byte (address) << 16;
    }
  else
    {
      rv = mem_get_byte (address);
      rv |= mem_get_byte (address + 1) << 8;
      rv |= mem_get_byte (address + 2) << 16;
    }
  COUNT (0, 3);
  E ();
  return rv;
}

unsigned long
mem_get_si (int address)
{
  unsigned long rv;
  S ("=>");
  if (rx_big_endian)
    {
      rv = mem_get_byte (address + 3);
      rv |= mem_get_byte (address + 2) << 8;
      rv |= mem_get_byte (address + 1) << 16;
      rv |= mem_get_byte (address) << 24;
    }
  else
    {
      rv = mem_get_byte (address);
      rv |= mem_get_byte (address + 1) << 8;
      rv |= mem_get_byte (address + 2) << 16;
      rv |= mem_get_byte (address + 3) << 24;
    }
  COUNT (0, 4);
  E ();
  return rv;
}

void
mem_get_blk (int address, void *bufptr, int nbytes)
{
  S ("=>");
  if (enable_counting)
    mem_counters[0][1] += nbytes;
  while (nbytes--)
    *(char *) bufptr++ = mem_get_byte (address++);
  E ();
}

int
sign_ext (int v, int bits)
{
  if (bits < 32)
    {
      v &= (1 << bits) - 1;
      if (v & (1 << (bits - 1)))
	v -= (1 << bits);
    }
  return v;
}

void
mem_set_content_type (int address, enum mem_content_type type)
{
  unsigned char *mt = rx_mem_ptr (address, MPA_CONTENT_TYPE);
  *mt = type;
}

void
mem_set_content_range (int start_address, int end_address, enum mem_content_type type)
{
  while (start_address < end_address)
    {
      int sz, ofs;
      unsigned char *mt;

      sz = end_address - start_address;
      ofs = start_address % L1_LEN;
      if (sz + ofs > L1_LEN)
	sz = L1_LEN - ofs;

      mt = rx_mem_ptr (start_address, MPA_CONTENT_TYPE);
      memset (mt, type, sz);

      start_address += sz;
    }
}

enum mem_content_type
mem_get_content_type (int address)
{
  unsigned char *mt = rx_mem_ptr (address, MPA_CONTENT_TYPE);
  return *mt;
}
Commit	Line	Data
4f8d4a38 DD	1	/* mem.c --- memory for RX simulator.
4f8d4a38 DD	2
dc3cf14f	3	Copyright (C) 2005, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
4f8d4a38 DD	4	Contributed by Red Hat, Inc.
	5
	6	This file is part of the GNU simulators.
	7
	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.
	12
	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.
	17
	18	You should have received a copy of the GNU General Public License
	19	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	20
	21	/* This slows down the simulator and we get some false negatives from
	22	gcc, like when it uses a long-sized hole to hold a byte-sized
	23	variable, knowing that it doesn't care about the other bits. But,
	24	if you need to track down a read-from-unitialized bug, set this to
	25	1. */
	26	#define RDCHECK 0
	27
93378652	28	#include "config.h"
4f8d4a38 DD	29	#include <stdio.h>
	30	#include <stdlib.h>
	31	#include <string.h>
	32
f9c7014e	33	#include "opcode/rx.h"
4f8d4a38 DD	34	#include "mem.h"
	35	#include "cpu.h"
	36	#include "syscalls.h"
	37	#include "misc.h"
	38	#include "err.h"
	39
	40	#define L1_BITS (10)
	41	#define L2_BITS (10)
93378652	42	#define OFF_BITS PAGE_BITS
4f8d4a38 DD	43
	44	#define L1_LEN (1 << L1_BITS)
	45	#define L2_LEN (1 << L2_BITS)
	46	#define OFF_LEN (1 << OFF_BITS)
	47
	48	static unsigned char **pt[L1_LEN];
	49	static unsigned char **ptr[L1_LEN];
f9c7014e	50	static RX_Opcode_Decoded ***ptdc[L1_LEN];
4f8d4a38 DD	51
	52	/* [ get=0/put=1 ][ byte size ] */
	53	static unsigned int mem_counters[2][5];
	54
	55	#define COUNT(isput,bytes) \
	56	if (verbose && enable_counting) mem_counters[isput][bytes]++
	57
	58	void
	59	init_mem (void)
	60	{
	61	int i, j;
	62
	63	for (i = 0; i < L1_LEN; i++)
	64	if (pt[i])
	65	{
	66	for (j = 0; j < L2_LEN; j++)
	67	if (pt[i][j])
	68	free (pt[i][j]);
	69	free (pt[i]);
	70	}
	71	memset (pt, 0, sizeof (pt));
	72	memset (ptr, 0, sizeof (ptr));
	73	memset (mem_counters, 0, sizeof (mem_counters));
	74	}
	75
93378652 DD	76	unsigned char *
93378652 DD	77	rx_mem_ptr (unsigned long address, enum mem_ptr_action action)
4f8d4a38 DD	78	{
	79	int pt1 = (address >> (L2_BITS + OFF_BITS)) & ((1 << L1_BITS) - 1);
	80	int pt2 = (address >> OFF_BITS) & ((1 << L2_BITS) - 1);
	81	int pto = address & ((1 << OFF_BITS) - 1);
	82
	83	if (address == 0)
	84	execution_error (SIM_ERR_NULL_POINTER_DEREFERENCE, 0);
	85
	86	if (pt[pt1] == 0)
	87	{
	88	pt[pt1] = (unsigned char ) calloc (L2_LEN, sizeof (char ));
	89	ptr[pt1] = (unsigned char ) calloc (L2_LEN, sizeof (char ));
f9c7014e	90	ptdc[pt1] = (RX_Opcode_Decoded *) calloc (L2_LEN, sizeof (RX_Opcode_Decoded *));
4f8d4a38 DD	91	}
	92	if (pt[pt1][pt2] == 0)
	93	{
	94	if (action == MPA_READING)
	95	execution_error (SIM_ERR_READ_UNWRITTEN_PAGES, address);
	96
f9c7014e DD	97	pt[pt1][pt2] = (unsigned char *) calloc (OFF_LEN, 1);
	98	ptr[pt1][pt2] = (unsigned char *) calloc (OFF_LEN, 1);
	99	ptdc[pt1][pt2] = (RX_Opcode_Decoded *) calloc (OFF_LEN, sizeof(RX_Opcode_Decoded ));
4f8d4a38 DD	100	}
	101	else if (action == MPA_READING
	102	&& ptr[pt1][pt2][pto] == MC_UNINIT)
	103	execution_error (SIM_ERR_READ_UNWRITTEN_BYTES, address);
	104
	105	if (action == MPA_WRITING)
	106	{
	107	if (ptr[pt1][pt2][pto] == MC_PUSHED_PC)
	108	execution_error (SIM_ERR_CORRUPT_STACK, address);
	109	ptr[pt1][pt2][pto] = MC_DATA;
f9c7014e DD	110	if (ptdc[pt1][pt2][pto])
	111	{
	112	free (ptdc[pt1][pt2][pto]);
	113	ptdc[pt1][pt2][pto] = NULL;
	114	}
4f8d4a38 DD	115	}
	116
	117	if (action == MPA_CONTENT_TYPE)
f9c7014e DD	118	return (unsigned char *) (ptr[pt1][pt2] + pto);
	119
	120	if (action == MPA_DECODE_CACHE)
	121	return (unsigned char *) (ptdc[pt1][pt2] + pto);
4f8d4a38 DD	122
	123	return pt[pt1][pt2] + pto;
	124	}
	125
f9c7014e DD	126	RX_Opcode_Decoded **
	127	rx_mem_decode_cache (unsigned long address)
	128	{
	129	return (RX_Opcode_Decoded **) rx_mem_ptr (address, MPA_DECODE_CACHE);
	130	}
	131
4f8d4a38 DD	132	static inline int
	133	is_reserved_address (unsigned int address)
	134	{
	135	return (address >= 0x00020000 && address < 0x00080000)
	136	\|\| (address >= 0x00100000 && address < 0x01000000)
	137	\|\| (address >= 0x08000000 && address < 0xff000000);
	138	}
	139
	140	static void
	141	used (int rstart, int i, int j)
	142	{
	143	int rend = i << (L2_BITS + OFF_BITS);
	144	rend += j << OFF_BITS;
	145	if (rstart == 0xe0000 && rend == 0xe1000)
	146	return;
	147	printf ("mem: %08x - %08x (%dk bytes)\n", rstart, rend - 1,
	148	(rend - rstart) / 1024);
	149	}
	150
	151	static char *
	152	mcs (int isput, int bytes)
	153	{
	154	return comma (mem_counters[isput][bytes]);
	155	}
	156
	157	void
	158	mem_usage_stats ()
	159	{
	160	int i, j;
	161	int rstart = 0;
	162	int pending = 0;
	163
	164	for (i = 0; i < L1_LEN; i++)
	165	if (pt[i])
	166	{
	167	for (j = 0; j < L2_LEN; j++)
	168	if (pt[i][j])
	169	{
	170	if (!pending)
	171	{
	172	pending = 1;
	173	rstart = (i << (L2_BITS + OFF_BITS)) + (j << OFF_BITS);
	174	}
	175	}
	176	else if (pending)
	177	{
	178	pending = 0;
	179	used (rstart, i, j);
	180	}
	181	}
	182	else
	183	{
	184	if (pending)
	185	{
	186	pending = 0;
	187	used (rstart, i, 0);
	188	}
	189	}
	190	/* mem foo: 123456789012 123456789012 123456789012 123456789012
	191	123456789012 */
	192	printf (" byte short 3byte long"
	193	" opcode\n");
	194	if (verbose > 1)
	195	{
196	/* Only use comma separated numbers when being very verbose.
197	Comma separated numbers are hard to parse in awk scripts. */
198	printf ("mem get: %12s %12s %12s %12s %12s\n", mcs (0, 1), mcs (0, 2),
199	mcs (0, 3), mcs (0, 4), mcs (0, 0));
200	printf ("mem put: %12s %12s %12s %12s\n", mcs (1, 1), mcs (1, 2),
201	mcs (1, 3), mcs (1, 4));
202	}
203	else
204	{
205	printf ("mem get: %12u %12u %12u %12u %12u\n",
206	mem_counters[0][1], mem_counters[0][2],
207	mem_counters[0][3], mem_counters[0][4],
208	mem_counters[0][0]);
209	printf ("mem put: %12u %12u %12u %12u\n",
210	mem_counters [1][1], mem_counters [1][2],
211	mem_counters [1][3], mem_counters [1][4]);
212	}
213	}
214
215	unsigned long
216	mem_usage_cycles (void)
217	{
218	unsigned long rv = mem_counters[0][0];
219	rv += mem_counters[0][1] * 1;
220	rv += mem_counters[0][2] * 2;
221	rv += mem_counters[0][3] * 3;
222	rv += mem_counters[0][4] * 4;
223	rv += mem_counters[1][1] * 1;
224	rv += mem_counters[1][2] * 2;
225	rv += mem_counters[1][3] * 3;
226	rv += mem_counters[1][4] * 4;
227	return rv;
228	}
229
230	static int tpr = 0;
231	static void
232	s (int address, char *dir)
233	{
234	if (tpr == 0)
235	printf ("MEM[%08x] %s", address, dir);
236	tpr++;
237	}
238
239	#define S(d) if (trace) s(address, d)
240	static void
241	e ()
242	{
243	if (!trace)
244	return;
245	tpr--;
246	if (tpr == 0)
247	printf ("\n");
248	}
249
250	static char
251	mtypec (int address)
252	{
93378652	253	unsigned char *cp = rx_mem_ptr (address, MPA_CONTENT_TYPE);
4f8d4a38 DD	254	return "udp"[*cp];
	255	}
	256
	257	#define E() if (trace) e()
	258
	259	void
	260	mem_put_byte (unsigned int address, unsigned char value)
	261	{
	262	unsigned char *m;
	263	char tc = ' ';
	264
	265	if (trace)
	266	tc = mtypec (address);
93378652	267	m = rx_mem_ptr (address, MPA_WRITING);
4f8d4a38 DD	268	if (trace)
	269	printf (" %02x%c", value, tc);
	270	*m = value;
	271	switch (address)
	272	{
93378652 DD	273	case 0x0008c02a: /* PA.DR */
93378652 DD	274	{
4f8d4a38	275	static int old_led = -1;
93378652	276	int red_on = 0;
4f8d4a38	277	int i;
93378652	278
4f8d4a38 DD	279	if (old_led != value)
4f8d4a38 DD	280	{
93378652 DD	281	fputs (" ", stdout);
93378652 DD	282	for (i = 0; i < 8; i++)
4f8d4a38	283	if (value & (1 << i))
93378652 DD	284	{
	285	if (! red_on)
	286	{
	287	fputs ("\033[31m", stdout);
	288	red_on = 1;
	289	}
	290	fputs (" @", stdout);
	291	}
4f8d4a38	292	else
93378652 DD	293	{
	294	if (red_on)
	295	{
	296	fputs ("\033[0m", stdout);
	297	red_on = 0;
	298	}
	299	fputs (" *", stdout);
	300	}
	301
	302	if (red_on)
	303	fputs ("\033[0m", stdout);
	304
	305	fputs ("\r", stdout);
4f8d4a38 DD	306	fflush (stdout);
	307	old_led = value;
	308	}
	309	}
	310	break;
	311
93378652 DD	312	#ifdef CYCLE_STATS
93378652 DD	313	case 0x0008c02b: /* PB.DR */
4f8d4a38	314	{
4f8d4a38	315	if (value == 0)
93378652 DD	316	halt_pipeline_stats ();
	317	else
	318	reset_pipeline_stats ();
	319	}
	320	#endif
	321
	322	case 0x00088263: /* SCI4.TDR */
	323	{
	324	static int pending_exit = 0;
	325	if (pending_exit == 2)
4f8d4a38	326	{
93378652 DD	327	step_result = RX_MAKE_EXITED(value);
93378652 DD	328	longjmp (decode_jmp_buf, 1);
4f8d4a38	329	}
93378652 DD	330	else if (value == 3)
93378652 DD	331	pending_exit ++;
4f8d4a38	332	else
93378652 DD	333	pending_exit = 0;
	334
	335	putchar(value);
4f8d4a38 DD	336	}
	337	break;
	338
	339	default:
	340	if (is_reserved_address (address))
	341	generate_access_exception ();
	342	}
	343	}
	344
	345	void
	346	mem_put_qi (int address, unsigned char value)
	347	{
	348	S ("<=");
	349	mem_put_byte (address, value & 0xff);
	350	E ();
	351	COUNT (1, 1);
	352	}
	353
f9c7014e	354	#ifdef CYCLE_ACCURATE
93378652	355	static int tpu_base;
f9c7014e	356	#endif
93378652	357
4f8d4a38 DD	358	void
	359	mem_put_hi (int address, unsigned short value)
	360	{
	361	S ("<=");
93378652	362	switch (address)
4f8d4a38	363	{
93378652 DD	364	#ifdef CYCLE_ACCURATE
	365	case 0x00088126: /* TPU1.TCNT */
	366	tpu_base = regs.cycle_count;
	367	break;
	368	case 0x00088136: /* TPU2.TCNT */
	369	tpu_base = regs.cycle_count;
	370	break;
	371	#endif
	372	default:
	373	if (rx_big_endian)
	374	{
	375	mem_put_byte (address, value >> 8);
	376	mem_put_byte (address + 1, value & 0xff);
	377	}
	378	else
	379	{
	380	mem_put_byte (address, value & 0xff);
	381	mem_put_byte (address + 1, value >> 8);
	382	}
4f8d4a38 DD	383	}
	384	E ();
	385	COUNT (1, 2);
	386	}
	387
	388	void
	389	mem_put_psi (int address, unsigned long value)
	390	{
	391	S ("<=");
	392	if (rx_big_endian)
	393	{
	394	mem_put_byte (address, value >> 16);
	395	mem_put_byte (address + 1, (value >> 8) & 0xff);
	396	mem_put_byte (address + 2, value & 0xff);
	397	}
	398	else
	399	{
	400	mem_put_byte (address, value & 0xff);
	401	mem_put_byte (address + 1, (value >> 8) & 0xff);
	402	mem_put_byte (address + 2, value >> 16);
	403	}
	404	E ();
	405	COUNT (1, 3);
	406	}
	407
	408	void
	409	mem_put_si (int address, unsigned long value)
	410	{
	411	S ("<=");
	412	if (rx_big_endian)
	413	{
	414	mem_put_byte (address + 0, (value >> 24) & 0xff);
	415	mem_put_byte (address + 1, (value >> 16) & 0xff);
	416	mem_put_byte (address + 2, (value >> 8) & 0xff);
	417	mem_put_byte (address + 3, value & 0xff);
	418	}
	419	else
	420	{
	421	mem_put_byte (address + 0, value & 0xff);
	422	mem_put_byte (address + 1, (value >> 8) & 0xff);
	423	mem_put_byte (address + 2, (value >> 16) & 0xff);
	424	mem_put_byte (address + 3, (value >> 24) & 0xff);
	425	}
	426	E ();
	427	COUNT (1, 4);
	428	}
	429
	430	void
	431	mem_put_blk (int address, void *bufptr, int nbytes)
	432	{
	433	S ("<=");
	434	if (enable_counting)
	435	mem_counters[1][1] += nbytes;
	436	while (nbytes--)
	437	mem_put_byte (address++, (unsigned char ) bufptr++);
	438	E ();
	439	}
	440
	441	unsigned char
	442	mem_get_pc (int address)
	443	{
93378652	444	unsigned char *m = rx_mem_ptr (address, MPA_READING);
4f8d4a38 DD	445	COUNT (0, 0);
	446	return *m;
	447	}
	448
	449	static unsigned char
	450	mem_get_byte (unsigned int address)
	451	{
	452	unsigned char *m;
	453
	454	S ("=>");
93378652	455	m = rx_mem_ptr (address, MPA_READING);
4f8d4a38 DD	456	switch (address)
4f8d4a38 DD	457	{
93378652	458	case 0x00088264: /* SCI4.SSR */
4f8d4a38	459	E();
93378652	460	return 0x04; /* transmitter empty */
4f8d4a38 DD	461	break;
	462	default:
	463	if (trace)
	464	printf (" %02x%c", *m, mtypec (address));
	465	if (is_reserved_address (address))
	466	generate_access_exception ();
	467	break;
	468	}
	469	E ();
	470	return *m;
	471	}
	472
	473	unsigned char
	474	mem_get_qi (int address)
	475	{
	476	unsigned char rv;
	477	S ("=>");
	478	rv = mem_get_byte (address);
	479	COUNT (0, 1);
	480	E ();
	481	return rv;
	482	}
	483
	484	unsigned short
	485	mem_get_hi (int address)
	486	{
	487	unsigned short rv;
	488	S ("=>");
93378652	489	switch (address)
4f8d4a38	490	{
93378652 DD	491	#ifdef CYCLE_ACCURATE
	492	case 0x00088126: /* TPU1.TCNT */
	493	rv = (regs.cycle_count - tpu_base) >> 16;
	494	break;
	495	case 0x00088136: /* TPU2.TCNT */
	496	rv = (regs.cycle_count - tpu_base) >> 0;
	497	break;
	498	#endif
	499
	500	default:
	501	if (rx_big_endian)
	502	{
	503	rv = mem_get_byte (address) << 8;
	504	rv \|= mem_get_byte (address + 1);
	505	}
	506	else
	507	{
	508	rv = mem_get_byte (address);
	509	rv \|= mem_get_byte (address + 1) << 8;
	510	}
4f8d4a38 DD	511	}
	512	COUNT (0, 2);
	513	E ();
	514	return rv;
	515	}
	516
	517	unsigned long
	518	mem_get_psi (int address)
	519	{
	520	unsigned long rv;
	521	S ("=>");
	522	if (rx_big_endian)
	523	{
	524	rv = mem_get_byte (address + 2);
	525	rv \|= mem_get_byte (address + 1) << 8;
	526	rv \|= mem_get_byte (address) << 16;
	527	}
	528	else
	529	{
	530	rv = mem_get_byte (address);
	531	rv \|= mem_get_byte (address + 1) << 8;
	532	rv \|= mem_get_byte (address + 2) << 16;
	533	}
	534	COUNT (0, 3);
	535	E ();
	536	return rv;
	537	}
	538
	539	unsigned long
	540	mem_get_si (int address)
	541	{
	542	unsigned long rv;
	543	S ("=>");
	544	if (rx_big_endian)
	545	{
	546	rv = mem_get_byte (address + 3);
	547	rv \|= mem_get_byte (address + 2) << 8;
	548	rv \|= mem_get_byte (address + 1) << 16;
	549	rv \|= mem_get_byte (address) << 24;
	550	}
	551	else
	552	{
	553	rv = mem_get_byte (address);
	554	rv \|= mem_get_byte (address + 1) << 8;
	555	rv \|= mem_get_byte (address + 2) << 16;
	556	rv \|= mem_get_byte (address + 3) << 24;
	557	}
	558	COUNT (0, 4);
	559	E ();
	560	return rv;
	561	}
	562
	563	void
	564	mem_get_blk (int address, void *bufptr, int nbytes)
	565	{
	566	S ("=>");
	567	if (enable_counting)
	568	mem_counters[0][1] += nbytes;
	569	while (nbytes--)
	570	(char ) bufptr++ = mem_get_byte (address++);
	571	E ();
	572	}
	573
	574	int
575	sign_ext (int v, int bits)
576	{
577	if (bits < 32)
578	{
579	v &= (1 << bits) - 1;
580	if (v & (1 << (bits - 1)))
581	v -= (1 << bits);
582	}
583	return v;
584	}
585
586	void
587	mem_set_content_type (int address, enum mem_content_type type)
588	{
93378652	589	unsigned char *mt = rx_mem_ptr (address, MPA_CONTENT_TYPE);
4f8d4a38 DD	590	*mt = type;
	591	}
	592
	593	void
	594	mem_set_content_range (int start_address, int end_address, enum mem_content_type type)
	595	{
	596	while (start_address < end_address)
	597	{
	598	int sz, ofs;
	599	unsigned char *mt;
	600
	601	sz = end_address - start_address;
	602	ofs = start_address % L1_LEN;
	603	if (sz + ofs > L1_LEN)
	604	sz = L1_LEN - ofs;
	605
93378652	606	mt = rx_mem_ptr (start_address, MPA_CONTENT_TYPE);
4f8d4a38 DD	607	memset (mt, type, sz);
	608
	609	start_address += sz;
	610	}
	611	}
	612
	613	enum mem_content_type
	614	mem_get_content_type (int address)
	615	{
93378652	616	unsigned char *mt = rx_mem_ptr (address, MPA_CONTENT_TYPE);
4f8d4a38 DD	617	return *mt;
4f8d4a38 DD	618	}