[deliverable/binutils-gdb.git] / sim / common / sim-memopt.c

/* Simulator memory option handling.
   Copyright (C) 1996-1999, 2007, 2008, 2009, 2010
   Free Software Foundation, Inc.
   Contributed by Cygnus Support.

This file is part of GDB, the GNU debugger.

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 "cconfig.h"

#include "sim-main.h"
#include "sim-assert.h"
#include "sim-options.h"

#ifdef HAVE_STRING_H
#include <string.h>
#else
#ifdef HAVE_STRINGS_H
#include <strings.h>
#endif
#endif
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_ERRNO_H
#include <errno.h>
#endif
#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif
#ifdef HAVE_SYS_MMAN_H
#include <sys/mman.h>
#endif
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif

/* Memory fill byte. */
static unsigned8 fill_byte_value;
static int fill_byte_flag = 0;

/* Memory mapping; see OPTION_MEMORY_MAPFILE. */
static int mmap_next_fd = -1;

/* Memory command line options. */

enum {
  OPTION_MEMORY_DELETE = OPTION_START,
  OPTION_MEMORY_REGION,
  OPTION_MEMORY_SIZE,
  OPTION_MEMORY_INFO,
  OPTION_MEMORY_ALIAS,
  OPTION_MEMORY_CLEAR,
  OPTION_MEMORY_FILL,
  OPTION_MEMORY_MAPFILE
};

static DECLARE_OPTION_HANDLER (memory_option_handler);

static const OPTION memory_options[] =
{
  { {"memory-delete", required_argument, NULL, OPTION_MEMORY_DELETE },
      '\0', "ADDRESS|all", "Delete memory at ADDRESS (all addresses)",
      memory_option_handler },
  { {"delete-memory", required_argument, NULL, OPTION_MEMORY_DELETE },
      '\0', "ADDRESS", NULL,
      memory_option_handler },

  { {"memory-region", required_argument, NULL, OPTION_MEMORY_REGION },
      '\0', "ADDRESS,SIZE[,MODULO]", "Add a memory region",
      memory_option_handler },

  { {"memory-alias", required_argument, NULL, OPTION_MEMORY_ALIAS },
      '\0', "ADDRESS,SIZE{,ADDRESS}", "Add memory shadow",
      memory_option_handler },

  { {"memory-size", required_argument, NULL, OPTION_MEMORY_SIZE },
      '\0', "<size>[in bytes, Kb (k suffix), Mb (m suffix) or Gb (g suffix)]",
     "Add memory at address zero", memory_option_handler },

  { {"memory-fill", required_argument, NULL, OPTION_MEMORY_FILL },
      '\0', "VALUE", "Fill subsequently added memory regions",
      memory_option_handler },

  { {"memory-clear", no_argument, NULL, OPTION_MEMORY_CLEAR },
      '\0', NULL, "Clear subsequently added memory regions",
      memory_option_handler },

#if defined(HAVE_MMAP) && defined(HAVE_MUNMAP)
  { {"memory-mapfile", required_argument, NULL, OPTION_MEMORY_MAPFILE },
      '\0', "FILE", "Memory-map next memory region from file",
      memory_option_handler },
#endif

  { {"memory-info", no_argument, NULL, OPTION_MEMORY_INFO },
      '\0', NULL, "List configurable memory regions",
      memory_option_handler },
  { {"info-memory", no_argument, NULL, OPTION_MEMORY_INFO },
      '\0', NULL, NULL,
      memory_option_handler },

  { {NULL, no_argument, NULL, 0}, '\0', NULL, NULL, NULL }
};


static sim_memopt *
do_memopt_add (SIM_DESC sd,
	       int level,
	       int space,
	       address_word addr,
	       address_word nr_bytes,
	       unsigned modulo,
	       sim_memopt **entry,
	       void *buffer)
{
  void *fill_buffer;
  unsigned fill_length;
  void *free_buffer;
  unsigned long free_length;

  if (buffer != NULL)
    {
      /* Buffer already given.  sim_memory_uninstall will free it. */
      sim_core_attach (sd, NULL,
		       level, access_read_write_exec, space,
		       addr, nr_bytes, modulo, NULL, buffer);

      free_buffer = buffer;
      free_length = 0;
      fill_buffer = buffer;
      fill_length = (modulo == 0) ? nr_bytes : modulo;
    }
  else
    {
      /* Allocate new well-aligned buffer, just as sim_core_attach(). */
      void *aligned_buffer;
      int padding = (addr % sizeof (unsigned64));
      unsigned long bytes = (modulo == 0 ? nr_bytes : modulo) + padding;

      free_buffer = NULL;
      free_length = bytes;

#ifdef HAVE_MMAP
      /* Memory map or malloc(). */
      if (mmap_next_fd >= 0)
	{
	  /* Check that given file is big enough. */
	  struct stat s;
	  int rc;

	  /* Some kernels will SIGBUS the application if mmap'd file
	     is not large enough.  */ 
	  rc = fstat (mmap_next_fd, &s);
	  if (rc < 0 || s.st_size < bytes)
	    {
	      sim_io_error (sd,
			    "Error, cannot confirm that mmap file is large enough "
			    "(>= %ld bytes)\n", bytes);
	    }

	  free_buffer = mmap (0, bytes, PROT_READ|PROT_WRITE, MAP_SHARED, mmap_next_fd, 0);
	  if (free_buffer == 0 || free_buffer == (char*)-1) /* MAP_FAILED */
	    {
	      sim_io_error (sd, "Error, cannot mmap file (%s).\n",
			    strerror(errno));
	    }
	}
#endif 

      /* Need heap allocation? */ 
      if (free_buffer == NULL)
	{
	  /* If filling with non-zero value, do not use clearing allocator. */
	  if (fill_byte_flag && fill_byte_value != 0)
	    free_buffer = xmalloc (bytes); /* don't clear */
	  else
	    free_buffer = zalloc (bytes); /* clear */
	}

      aligned_buffer = (char*) free_buffer + padding;

      sim_core_attach (sd, NULL,
		       level, access_read_write_exec, space,
		       addr, nr_bytes, modulo, NULL, aligned_buffer);

      fill_buffer = aligned_buffer;
      fill_length = (modulo == 0) ? nr_bytes : modulo;

      /* If we just used a clearing allocator, and are about to fill with
         zero, truncate the redundant fill operation. */

      if (fill_byte_flag && fill_byte_value == 0)
         fill_length = 1; /* avoid boundary length=0 case */
    }

  if (fill_byte_flag)
    {
      ASSERT (fill_buffer != 0);
      memset ((char*) fill_buffer, fill_byte_value, fill_length);
    }

  while ((*entry) != NULL)
    entry = &(*entry)->next;
  (*entry) = ZALLOC (sim_memopt);
  (*entry)->level = level;
  (*entry)->space = space;
  (*entry)->addr = addr;
  (*entry)->nr_bytes = nr_bytes;
  (*entry)->modulo = modulo;
  (*entry)->buffer = free_buffer;

  /* Record memory unmapping info.  */
  if (mmap_next_fd >= 0)
    {
      (*entry)->munmap_length = free_length;
      close (mmap_next_fd);
      mmap_next_fd = -1;
    }
  else
    (*entry)->munmap_length = 0;

  return (*entry);
}

static SIM_RC
do_memopt_delete (SIM_DESC sd,
		  int level,
		  int space,
		  address_word addr)
{
  sim_memopt **entry = &STATE_MEMOPT (sd);
  sim_memopt *alias;
  while ((*entry) != NULL
	 && ((*entry)->level != level
	      || (*entry)->space != space
	      || (*entry)->addr != addr))
    entry = &(*entry)->next;
  if ((*entry) == NULL)
    {
      sim_io_eprintf (sd, "Memory at 0x%lx not found, not deleted\n",
		      (long) addr);
      return SIM_RC_FAIL;
    }
  /* delete any buffer */
  if ((*entry)->buffer != NULL)
    {
#ifdef HAVE_MUNMAP
      if ((*entry)->munmap_length > 0)
	munmap ((*entry)->buffer, (*entry)->munmap_length);
      else
#endif
	zfree ((*entry)->buffer);
    }

  /* delete it and its aliases */
  alias = *entry;
  *entry = (*entry)->next;
  while (alias != NULL)
    {
      sim_memopt *dead = alias;
      alias = alias->alias;
      sim_core_detach (sd, NULL, dead->level, dead->space, dead->addr);
      zfree (dead);
    }
  return SIM_RC_OK;
}


static char *
parse_size (char *chp,
	    address_word *nr_bytes,
	    unsigned *modulo)
{
  /* <nr_bytes>[K|M|G] [ "%" <modulo> ] */
  *nr_bytes = strtoul (chp, &chp, 0);
  switch (*chp)
    {
    case '%':
      *modulo = strtoul (chp + 1, &chp, 0);
      break;
    case 'g': case 'G': /* Gigabyte suffix.  */
      *nr_bytes <<= 10;
      /* Fall through.  */
    case 'm': case 'M': /* Megabyte suffix.  */
      *nr_bytes <<= 10;
      /* Fall through.  */
    case 'k': case 'K': /* Kilobyte suffix.  */
      *nr_bytes <<= 10;
      /* Check for a modulo specifier after the suffix.  */
      ++ chp;
      if (* chp == 'b' || * chp == 'B')
	++ chp;
      if (* chp == '%')
	*modulo = strtoul (chp + 1, &chp, 0);
      break;
    }
  return chp;
}

static char *
parse_ulong_value (char *chp,
		     unsigned long *value)
{
  *value = strtoul (chp, &chp, 0);
  return chp;
}

static char *
parse_addr (char *chp,
	    int *level,
	    int *space,
	    address_word *addr)
{
  /* [ <space> ": " ] <addr> [ "@" <level> ] */
  *addr = (unsigned long) strtoul (chp, &chp, 0);
  if (*chp == ':')
    {
      *space = *addr;
      *addr = (unsigned long) strtoul (chp + 1, &chp, 0);
    }
  if (*chp == '@')
    {
      *level = strtoul (chp + 1, &chp, 0);
    }
  return chp;
}


static SIM_RC
memory_option_handler (SIM_DESC sd, sim_cpu *cpu, int opt,
		       char *arg, int is_command)
{
  switch (opt)
    {

    case OPTION_MEMORY_DELETE:
      if (strcasecmp (arg, "all") == 0)
	{
	  while (STATE_MEMOPT (sd) != NULL)
	    do_memopt_delete (sd,
			      STATE_MEMOPT (sd)->level,
			      STATE_MEMOPT (sd)->space,
			      STATE_MEMOPT (sd)->addr);
	  return SIM_RC_OK;
	}
      else
	{
	  int level = 0;
	  int space = 0;
	  address_word addr = 0;
	  parse_addr (arg, &level, &space, &addr);
	  return do_memopt_delete (sd, level, space, addr);
	}
    
    case OPTION_MEMORY_REGION:
      {
	char *chp = arg;
	int level = 0;
	int space = 0;
	address_word addr = 0;
	address_word nr_bytes = 0;
	unsigned modulo = 0;
	/* parse the arguments */
	chp = parse_addr (chp, &level, &space, &addr);
	if (*chp != ',')
	  {
	    sim_io_eprintf (sd, "Missing size for memory-region\n");
	    return SIM_RC_FAIL;
	  }
	chp = parse_size (chp + 1, &nr_bytes, &modulo);
	/* old style */
	if (*chp == ',')
	  modulo = strtoul (chp + 1, &chp, 0);
	/* try to attach/insert it */
	do_memopt_add (sd, level, space, addr, nr_bytes, modulo,
		       &STATE_MEMOPT (sd), NULL);
	return SIM_RC_OK;
      }

    case OPTION_MEMORY_ALIAS:
      {
	char *chp = arg;
	int level = 0;
	int space = 0;
	address_word addr = 0;
	address_word nr_bytes = 0;
	unsigned modulo = 0;
	sim_memopt *entry;
	/* parse the arguments */
	chp = parse_addr (chp, &level, &space, &addr);
	if (*chp != ',')
	  {
	    sim_io_eprintf (sd, "Missing size for memory-region\n");
	    return SIM_RC_FAIL;
	  }
	chp = parse_size (chp + 1, &nr_bytes, &modulo);
	/* try to attach/insert the main record */
	entry = do_memopt_add (sd, level, space, addr, nr_bytes, modulo,
			       &STATE_MEMOPT (sd),
			       NULL);
	/* now attach all the aliases */
	while (*chp == ',')
	  {
	    int a_level = level;
	    int a_space = space;
	    address_word a_addr = addr;
	    chp = parse_addr (chp + 1, &a_level, &a_space, &a_addr);
	    do_memopt_add (sd, a_level, a_space, a_addr, nr_bytes, modulo,
			   &entry->alias, entry->buffer);
	  }
	return SIM_RC_OK;
      }

    case OPTION_MEMORY_SIZE:
      {
	int level = 0;
	int space = 0;
	address_word addr = 0;
	address_word nr_bytes = 0;
	unsigned modulo = 0;
	/* parse the arguments */
	parse_size (arg, &nr_bytes, &modulo);
	/* try to attach/insert it */
	do_memopt_add (sd, level, space, addr, nr_bytes, modulo,
		       &STATE_MEMOPT (sd), NULL);
	return SIM_RC_OK;
      }

    case OPTION_MEMORY_CLEAR:
      {
	fill_byte_value = (unsigned8) 0;
	fill_byte_flag = 1;
	return SIM_RC_OK;
	break;
      }

    case OPTION_MEMORY_FILL:
      {
	unsigned long fill_value;
	parse_ulong_value (arg, &fill_value);
	if (fill_value > 255)
	  {
	    sim_io_eprintf (sd, "Missing fill value between 0 and 255\n");
	    return SIM_RC_FAIL;
	  }
	fill_byte_value = (unsigned8) fill_value;
	fill_byte_flag = 1;
	return SIM_RC_OK;
	break;
      }

    case OPTION_MEMORY_MAPFILE:
      {
	if (mmap_next_fd >= 0)
	  {
	    sim_io_eprintf (sd, "Duplicate memory-mapfile option\n");
	    return SIM_RC_FAIL;
	  }

	mmap_next_fd = open (arg, O_RDWR);
	if (mmap_next_fd < 0)
	  {
	    sim_io_eprintf (sd, "Cannot open file `%s': %s\n",
			    arg, strerror(errno));
	    return SIM_RC_FAIL;
	  }

	return SIM_RC_OK;
      }

    case OPTION_MEMORY_INFO:
      {
	sim_memopt *entry;
	sim_io_printf (sd, "Memory maps:\n");
	for (entry = STATE_MEMOPT (sd); entry != NULL; entry = entry->next)
	  {
	    sim_memopt *alias;
	    sim_io_printf (sd, " memory");
	    if (entry->alias == NULL)
	      sim_io_printf (sd, " region ");
	    else
	      sim_io_printf (sd, " alias ");
	    if (entry->space != 0)
	      sim_io_printf (sd, "0x%lx:", (long) entry->space);
	    sim_io_printf (sd, "0x%08lx", (long) entry->addr);
	    if (entry->level != 0)
	      sim_io_printf (sd, "@0x%lx", (long) entry->level);
	    sim_io_printf (sd, ",0x%lx",
			   (long) entry->nr_bytes);
	    if (entry->modulo != 0)
	      sim_io_printf (sd, "%%0x%lx", (long) entry->modulo);
	    for (alias = entry->alias;
		 alias != NULL;
		 alias = alias->next)
	      {
		if (alias->space != 0)
		  sim_io_printf (sd, "0x%lx:", (long) alias->space);
		sim_io_printf (sd, ",0x%08lx", (long) alias->addr);
		if (alias->level != 0)
		  sim_io_printf (sd, "@0x%lx", (long) alias->level);
	      }
	    sim_io_printf (sd, "\n");
	  }
	return SIM_RC_OK;
	break;
      }

    default:
      sim_io_eprintf (sd, "Unknown memory option %d\n", opt);
      return SIM_RC_FAIL;

    }

  return SIM_RC_FAIL;
}


/* "memory" module install handler.

   This is called via sim_module_install to install the "memory" subsystem
   into the simulator.  */

static MODULE_INIT_FN sim_memory_init;
static MODULE_UNINSTALL_FN sim_memory_uninstall;

SIM_RC
sim_memopt_install (SIM_DESC sd)
{
  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
  sim_add_option_table (sd, NULL, memory_options);
  sim_module_add_uninstall_fn (sd, sim_memory_uninstall);
  sim_module_add_init_fn (sd, sim_memory_init);
  return SIM_RC_OK;
}


/* Uninstall the "memory" subsystem from the simulator.  */

static void
sim_memory_uninstall (SIM_DESC sd)
{
  sim_memopt **entry = &STATE_MEMOPT (sd);
  sim_memopt *alias;

  while ((*entry) != NULL)
    {
      /* delete any buffer */
      if ((*entry)->buffer != NULL)
	{
#ifdef HAVE_MUNMAP
	  if ((*entry)->munmap_length > 0)
	    munmap ((*entry)->buffer, (*entry)->munmap_length);
	  else
#endif
	    zfree ((*entry)->buffer);
	}

      /* delete it and its aliases */
      alias = *entry;

      /* next victim */
      *entry = (*entry)->next;

      while (alias != NULL)
	{
	  sim_memopt *dead = alias;
	  alias = alias->alias;
	  sim_core_detach (sd, NULL, dead->level, dead->space, dead->addr);
	  zfree (dead);
	}
    }
}


static SIM_RC
sim_memory_init (SIM_DESC sd)
{
  /* Reinitialize option modifier flags, in case they were left
     over from a previous sim startup event.  */
  fill_byte_flag = 0;
  mmap_next_fd = -1;

  return SIM_RC_OK;
}
Commit	Line	Data
c906108c	1	/* Simulator memory option handling.
dc3cf14f JB	2	Copyright (C) 1996-1999, 2007, 2008, 2009, 2010
dc3cf14f JB	3	Free Software Foundation, Inc.
c906108c SS	4	Contributed by Cygnus Support.
	5
	6	This file is part of GDB, the GNU debugger.
	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
4744ac1b JB	10	the Free Software Foundation; either version 3 of the License, or
4744ac1b JB	11	(at your option) any later version.
c906108c SS	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
4744ac1b JB	18	You should have received a copy of the GNU General Public License
4744ac1b JB	19	along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c	20
764f1408 FCE	21	#include "cconfig.h"
764f1408 FCE	22
c906108c SS	23	#include "sim-main.h"
	24	#include "sim-assert.h"
	25	#include "sim-options.h"
	26
	27	#ifdef HAVE_STRING_H
	28	#include <string.h>
	29	#else
	30	#ifdef HAVE_STRINGS_H
	31	#include <strings.h>
	32	#endif
	33	#endif
	34	#ifdef HAVE_STDLIB_H
	35	#include <stdlib.h>
	36	#endif
764f1408 FCE	37	#ifdef HAVE_ERRNO_H
	38	#include <errno.h>
	39	#endif
	40	#ifdef HAVE_FCNTL_H
	41	#include <fcntl.h>
	42	#endif
	43	#ifdef HAVE_SYS_MMAN_H
	44	#include <sys/mman.h>
	45	#endif
	46	#ifdef HAVE_SYS_STAT_H
	47	#include <sys/stat.h>
	48	#endif
bf962092 AC	49	#ifdef HAVE_UNISTD_H
	50	#include <unistd.h>
	51	#endif
c906108c	52
764f1408	53	/* Memory fill byte. */
c906108c SS	54	static unsigned8 fill_byte_value;
	55	static int fill_byte_flag = 0;
	56
764f1408 FCE	57	/* Memory mapping; see OPTION_MEMORY_MAPFILE. */
	58	static int mmap_next_fd = -1;
	59
c906108c SS	60	/* Memory command line options. */
	61
	62	enum {
	63	OPTION_MEMORY_DELETE = OPTION_START,
	64	OPTION_MEMORY_REGION,
	65	OPTION_MEMORY_SIZE,
	66	OPTION_MEMORY_INFO,
	67	OPTION_MEMORY_ALIAS,
	68	OPTION_MEMORY_CLEAR,
764f1408 FCE	69	OPTION_MEMORY_FILL,
764f1408 FCE	70	OPTION_MEMORY_MAPFILE
c906108c SS	71	};
	72
	73	static DECLARE_OPTION_HANDLER (memory_option_handler);
	74
	75	static const OPTION memory_options[] =
	76	{
	77	{ {"memory-delete", required_argument, NULL, OPTION_MEMORY_DELETE },
	78	'\0', "ADDRESS\|all", "Delete memory at ADDRESS (all addresses)",
	79	memory_option_handler },
	80	{ {"delete-memory", required_argument, NULL, OPTION_MEMORY_DELETE },
	81	'\0', "ADDRESS", NULL,
	82	memory_option_handler },
	83
	84	{ {"memory-region", required_argument, NULL, OPTION_MEMORY_REGION },
	85	'\0', "ADDRESS,SIZE[,MODULO]", "Add a memory region",
	86	memory_option_handler },
	87
	88	{ {"memory-alias", required_argument, NULL, OPTION_MEMORY_ALIAS },
	89	'\0', "ADDRESS,SIZE{,ADDRESS}", "Add memory shadow",
	90	memory_option_handler },
	91
	92	{ {"memory-size", required_argument, NULL, OPTION_MEMORY_SIZE },
f40f1a01 NC	93	'\0', "<size>[in bytes, Kb (k suffix), Mb (m suffix) or Gb (g suffix)]",
f40f1a01 NC	94	"Add memory at address zero", memory_option_handler },
c906108c SS	95
	96	{ {"memory-fill", required_argument, NULL, OPTION_MEMORY_FILL },
	97	'\0', "VALUE", "Fill subsequently added memory regions",
	98	memory_option_handler },
	99
	100	{ {"memory-clear", no_argument, NULL, OPTION_MEMORY_CLEAR },
	101	'\0', NULL, "Clear subsequently added memory regions",
	102	memory_option_handler },
	103
764f1408 FCE	104	#if defined(HAVE_MMAP) && defined(HAVE_MUNMAP)
	105	{ {"memory-mapfile", required_argument, NULL, OPTION_MEMORY_MAPFILE },
	106	'\0', "FILE", "Memory-map next memory region from file",
	107	memory_option_handler },
	108	#endif
	109
c906108c SS	110	{ {"memory-info", no_argument, NULL, OPTION_MEMORY_INFO },
	111	'\0', NULL, "List configurable memory regions",
	112	memory_option_handler },
	113	{ {"info-memory", no_argument, NULL, OPTION_MEMORY_INFO },
	114	'\0', NULL, NULL,
	115	memory_option_handler },
	116
	117	{ {NULL, no_argument, NULL, 0}, '\0', NULL, NULL, NULL }
	118	};
	119
	120
	121	static sim_memopt *
	122	do_memopt_add (SIM_DESC sd,
	123	int level,
	124	int space,
	125	address_word addr,
	126	address_word nr_bytes,
	127	unsigned modulo,
	128	sim_memopt **entry,
	129	void *buffer)
	130	{
	131	void *fill_buffer;
	132	unsigned fill_length;
	133	void *free_buffer;
764f1408	134	unsigned long free_length;
c906108c SS	135
	136	if (buffer != NULL)
	137	{
	138	/* Buffer already given. sim_memory_uninstall will free it. */
	139	sim_core_attach (sd, NULL,
	140	level, access_read_write_exec, space,
	141	addr, nr_bytes, modulo, NULL, buffer);
	142
	143	free_buffer = buffer;
764f1408	144	free_length = 0;
c906108c SS	145	fill_buffer = buffer;
	146	fill_length = (modulo == 0) ? nr_bytes : modulo;
	147	}
	148	else
	149	{
	150	/* Allocate new well-aligned buffer, just as sim_core_attach(). */
	151	void *aligned_buffer;
	152	int padding = (addr % sizeof (unsigned64));
	153	unsigned long bytes = (modulo == 0 ? nr_bytes : modulo) + padding;
	154
764f1408 FCE	155	free_buffer = NULL;
764f1408 FCE	156	free_length = bytes;
c906108c	157
764f1408 FCE	158	#ifdef HAVE_MMAP
	159	/* Memory map or malloc(). */
	160	if (mmap_next_fd >= 0)
	161	{
	162	/* Check that given file is big enough. */
	163	struct stat s;
	164	int rc;
	165
	166	/* Some kernels will SIGBUS the application if mmap'd file
	167	is not large enough. */
	168	rc = fstat (mmap_next_fd, &s);
	169	if (rc < 0 \|\| s.st_size < bytes)
	170	{
	171	sim_io_error (sd,
	172	"Error, cannot confirm that mmap file is large enough "
bf962092	173	"(>= %ld bytes)\n", bytes);
764f1408 FCE	174	}
	175
	176	free_buffer = mmap (0, bytes, PROT_READ\|PROT_WRITE, MAP_SHARED, mmap_next_fd, 0);
	177	if (free_buffer == 0 \|\| free_buffer == (char)-1) / MAP_FAILED */
	178	{
	179	sim_io_error (sd, "Error, cannot mmap file (%s).\n",
	180	strerror(errno));
	181	}
	182	}
	183	#endif
	184
	185	/* Need heap allocation? */
	186	if (free_buffer == NULL)
	187	{
	188	/* If filling with non-zero value, do not use clearing allocator. */
	189	if (fill_byte_flag && fill_byte_value != 0)
	190	free_buffer = xmalloc (bytes); /* don't clear */
	191	else
	192	free_buffer = zalloc (bytes); /* clear */
	193	}
c906108c SS	194
	195	aligned_buffer = (char*) free_buffer + padding;
	196
	197	sim_core_attach (sd, NULL,
	198	level, access_read_write_exec, space,
	199	addr, nr_bytes, modulo, NULL, aligned_buffer);
	200
	201	fill_buffer = aligned_buffer;
	202	fill_length = (modulo == 0) ? nr_bytes : modulo;
	203
	204	/* If we just used a clearing allocator, and are about to fill with
	205	zero, truncate the redundant fill operation. */
	206
	207	if (fill_byte_flag && fill_byte_value == 0)
	208	fill_length = 1; /* avoid boundary length=0 case */
	209	}
	210
	211	if (fill_byte_flag)
	212	{
	213	ASSERT (fill_buffer != 0);
	214	memset ((char*) fill_buffer, fill_byte_value, fill_length);
	215	}
	216
	217	while ((*entry) != NULL)
	218	entry = &(*entry)->next;
	219	(*entry) = ZALLOC (sim_memopt);
	220	(*entry)->level = level;
	221	(*entry)->space = space;
	222	(*entry)->addr = addr;
	223	(*entry)->nr_bytes = nr_bytes;
	224	(*entry)->modulo = modulo;
	225	(*entry)->buffer = free_buffer;
	226
764f1408 FCE	227	/* Record memory unmapping info. */
	228	if (mmap_next_fd >= 0)
	229	{
	230	(*entry)->munmap_length = free_length;
	231	close (mmap_next_fd);
	232	mmap_next_fd = -1;
	233	}
	234	else
	235	(*entry)->munmap_length = 0;
	236
c906108c SS	237	return (*entry);
	238	}
	239
	240	static SIM_RC
	241	do_memopt_delete (SIM_DESC sd,
	242	int level,
	243	int space,
	244	address_word addr)
	245	{
	246	sim_memopt **entry = &STATE_MEMOPT (sd);
	247	sim_memopt *alias;
	248	while ((*entry) != NULL
	249	&& ((*entry)->level != level
	250	\|\| (*entry)->space != space
	251	\|\| (*entry)->addr != addr))
	252	entry = &(*entry)->next;
	253	if ((*entry) == NULL)
	254	{
	255	sim_io_eprintf (sd, "Memory at 0x%lx not found, not deleted\n",
	256	(long) addr);
	257	return SIM_RC_FAIL;
	258	}
	259	/* delete any buffer */
	260	if ((*entry)->buffer != NULL)
764f1408 FCE	261	{
	262	#ifdef HAVE_MUNMAP
	263	if ((*entry)->munmap_length > 0)
	264	munmap ((entry)->buffer, (entry)->munmap_length);
	265	else
	266	#endif
	267	zfree ((*entry)->buffer);
	268	}
	269
c906108c SS	270	/* delete it and its aliases */
	271	alias = *entry;
	272	entry = (entry)->next;
	273	while (alias != NULL)
	274	{
	275	sim_memopt *dead = alias;
	276	alias = alias->alias;
	277	sim_core_detach (sd, NULL, dead->level, dead->space, dead->addr);
	278	zfree (dead);
	279	}
	280	return SIM_RC_OK;
	281	}
	282
	283
	284	static char *
	285	parse_size (char *chp,
	286	address_word *nr_bytes,
	287	unsigned *modulo)
	288	{
f40f1a01	289	/* <nr_bytes>[K\|M\|G] [ "%" <modulo> ] */
c906108c	290	*nr_bytes = strtoul (chp, &chp, 0);
f40f1a01	291	switch (*chp)
c906108c	292	{
f40f1a01	293	case '%':
c906108c	294	*modulo = strtoul (chp + 1, &chp, 0);
f40f1a01 NC	295	break;
	296	case 'g': case 'G': /* Gigabyte suffix. */
	297	*nr_bytes <<= 10;
	298	/* Fall through. */
	299	case 'm': case 'M': /* Megabyte suffix. */
	300	*nr_bytes <<= 10;
	301	/* Fall through. */
	302	case 'k': case 'K': /* Kilobyte suffix. */
	303	*nr_bytes <<= 10;
	304	/* Check for a modulo specifier after the suffix. */
	305	++ chp;
	306	if (* chp == 'b' \|\| * chp == 'B')
	307	++ chp;
	308	if (* chp == '%')
	309	*modulo = strtoul (chp + 1, &chp, 0);
	310	break;
c906108c SS	311	}
	312	return chp;
	313	}
	314
	315	static char *
	316	parse_ulong_value (char *chp,
	317	unsigned long *value)
	318	{
	319	*value = strtoul (chp, &chp, 0);
	320	return chp;
	321	}
	322
	323	static char *
	324	parse_addr (char *chp,
	325	int *level,
	326	int *space,
	327	address_word *addr)
	328	{
	329	/* [ <space> ": " ] <addr> [ "@" <level> ] */
	330	*addr = (unsigned long) strtoul (chp, &chp, 0);
	331	if (*chp == ':')
	332	{
	333	space = addr;
	334	*addr = (unsigned long) strtoul (chp + 1, &chp, 0);
	335	}
	336	if (*chp == '@')
	337	{
	338	*level = strtoul (chp + 1, &chp, 0);
	339	}
	340	return chp;
	341	}
	342
	343
	344	static SIM_RC
	345	memory_option_handler (SIM_DESC sd, sim_cpu *cpu, int opt,
	346	char *arg, int is_command)
	347	{
	348	switch (opt)
	349	{
	350
	351	case OPTION_MEMORY_DELETE:
	352	if (strcasecmp (arg, "all") == 0)
	353	{
	354	while (STATE_MEMOPT (sd) != NULL)
	355	do_memopt_delete (sd,
	356	STATE_MEMOPT (sd)->level,
	357	STATE_MEMOPT (sd)->space,
	358	STATE_MEMOPT (sd)->addr);
	359	return SIM_RC_OK;
	360	}
	361	else
	362	{
	363	int level = 0;
	364	int space = 0;
	365	address_word addr = 0;
	366	parse_addr (arg, &level, &space, &addr);
	367	return do_memopt_delete (sd, level, space, addr);
	368	}
	369
	370	case OPTION_MEMORY_REGION:
	371	{
	372	char *chp = arg;
	373	int level = 0;
	374	int space = 0;
375	address_word addr = 0;
376	address_word nr_bytes = 0;
377	unsigned modulo = 0;
378	/* parse the arguments */
379	chp = parse_addr (chp, &level, &space, &addr);
380	if (*chp != ',')
381	{
382	sim_io_eprintf (sd, "Missing size for memory-region\n");
383	return SIM_RC_FAIL;
384	}
385	chp = parse_size (chp + 1, &nr_bytes, &modulo);
386	/* old style */
387	if (*chp == ',')
388	modulo = strtoul (chp + 1, &chp, 0);
389	/* try to attach/insert it */
390	do_memopt_add (sd, level, space, addr, nr_bytes, modulo,
391	&STATE_MEMOPT (sd), NULL);
392	return SIM_RC_OK;
393	}
394
395	case OPTION_MEMORY_ALIAS:
396	{
397	char *chp = arg;
398	int level = 0;
399	int space = 0;
400	address_word addr = 0;
401	address_word nr_bytes = 0;
402	unsigned modulo = 0;
403	sim_memopt *entry;
404	/* parse the arguments */
405	chp = parse_addr (chp, &level, &space, &addr);
406	if (*chp != ',')
407	{
408	sim_io_eprintf (sd, "Missing size for memory-region\n");
409	return SIM_RC_FAIL;
410	}
411	chp = parse_size (chp + 1, &nr_bytes, &modulo);
412	/* try to attach/insert the main record */
413	entry = do_memopt_add (sd, level, space, addr, nr_bytes, modulo,
414	&STATE_MEMOPT (sd),
415	NULL);
416	/* now attach all the aliases */
417	while (*chp == ',')
418	{
419	int a_level = level;
420	int a_space = space;
421	address_word a_addr = addr;
422	chp = parse_addr (chp + 1, &a_level, &a_space, &a_addr);
423	do_memopt_add (sd, a_level, a_space, a_addr, nr_bytes, modulo,
424	&entry->alias, entry->buffer);
425	}
426	return SIM_RC_OK;
427	}
428
429	case OPTION_MEMORY_SIZE:
430	{
431	int level = 0;
432	int space = 0;
433	address_word addr = 0;
434	address_word nr_bytes = 0;
435	unsigned modulo = 0;
436	/* parse the arguments */
437	parse_size (arg, &nr_bytes, &modulo);
438	/* try to attach/insert it */
439	do_memopt_add (sd, level, space, addr, nr_bytes, modulo,
440	&STATE_MEMOPT (sd), NULL);
441	return SIM_RC_OK;
442	}
443
444	case OPTION_MEMORY_CLEAR:
445	{
446	fill_byte_value = (unsigned8) 0;
447	fill_byte_flag = 1;
448	return SIM_RC_OK;
449	break;
450	}
451
452	case OPTION_MEMORY_FILL:
453	{
454	unsigned long fill_value;
455	parse_ulong_value (arg, &fill_value);
456	if (fill_value > 255)
457	{
458	sim_io_eprintf (sd, "Missing fill value between 0 and 255\n");
459	return SIM_RC_FAIL;
460	}
461	fill_byte_value = (unsigned8) fill_value;
462	fill_byte_flag = 1;
463	return SIM_RC_OK;
464	break;
465	}
466
764f1408 FCE	467	case OPTION_MEMORY_MAPFILE:
	468	{
	469	if (mmap_next_fd >= 0)
	470	{
	471	sim_io_eprintf (sd, "Duplicate memory-mapfile option\n");
	472	return SIM_RC_FAIL;
	473	}
	474
	475	mmap_next_fd = open (arg, O_RDWR);
	476	if (mmap_next_fd < 0)
	477	{
	478	sim_io_eprintf (sd, "Cannot open file `%s': %s\n",
	479	arg, strerror(errno));
	480	return SIM_RC_FAIL;
	481	}
	482
	483	return SIM_RC_OK;
	484	}
	485
c906108c SS	486	case OPTION_MEMORY_INFO:
	487	{
	488	sim_memopt *entry;
	489	sim_io_printf (sd, "Memory maps:\n");
	490	for (entry = STATE_MEMOPT (sd); entry != NULL; entry = entry->next)
	491	{
	492	sim_memopt *alias;
	493	sim_io_printf (sd, " memory");
	494	if (entry->alias == NULL)
	495	sim_io_printf (sd, " region ");
	496	else
	497	sim_io_printf (sd, " alias ");
	498	if (entry->space != 0)
	499	sim_io_printf (sd, "0x%lx:", (long) entry->space);
	500	sim_io_printf (sd, "0x%08lx", (long) entry->addr);
	501	if (entry->level != 0)
	502	sim_io_printf (sd, "@0x%lx", (long) entry->level);
	503	sim_io_printf (sd, ",0x%lx",
	504	(long) entry->nr_bytes);
	505	if (entry->modulo != 0)
	506	sim_io_printf (sd, "%%0x%lx", (long) entry->modulo);
	507	for (alias = entry->alias;
	508	alias != NULL;
	509	alias = alias->next)
	510	{
	511	if (alias->space != 0)
	512	sim_io_printf (sd, "0x%lx:", (long) alias->space);
	513	sim_io_printf (sd, ",0x%08lx", (long) alias->addr);
	514	if (alias->level != 0)
	515	sim_io_printf (sd, "@0x%lx", (long) alias->level);
	516	}
	517	sim_io_printf (sd, "\n");
	518	}
	519	return SIM_RC_OK;
	520	break;
	521	}
	522
	523	default:
	524	sim_io_eprintf (sd, "Unknown memory option %d\n", opt);
	525	return SIM_RC_FAIL;
	526
	527	}
	528
	529	return SIM_RC_FAIL;
	530	}
	531
	532
	533	/* "memory" module install handler.
	534
	535	This is called via sim_module_install to install the "memory" subsystem
	536	into the simulator. */
	537
	538	static MODULE_INIT_FN sim_memory_init;
	539	static MODULE_UNINSTALL_FN sim_memory_uninstall;
	540
	541	SIM_RC
	542	sim_memopt_install (SIM_DESC sd)
	543	{
	544	SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
	545	sim_add_option_table (sd, NULL, memory_options);
	546	sim_module_add_uninstall_fn (sd, sim_memory_uninstall);
	547	sim_module_add_init_fn (sd, sim_memory_init);
	548	return SIM_RC_OK;
	549	}
550
551
552	/* Uninstall the "memory" subsystem from the simulator. */
553
554	static void
555	sim_memory_uninstall (SIM_DESC sd)
556	{
557	sim_memopt **entry = &STATE_MEMOPT (sd);
558	sim_memopt *alias;
559
560	while ((*entry) != NULL)
561	{
562	/* delete any buffer */
563	if ((*entry)->buffer != NULL)
764f1408 FCE	564	{
	565	#ifdef HAVE_MUNMAP
	566	if ((*entry)->munmap_length > 0)
	567	munmap ((entry)->buffer, (entry)->munmap_length);
	568	else
	569	#endif
	570	zfree ((*entry)->buffer);
	571	}
c906108c SS	572
	573	/* delete it and its aliases */
	574	alias = *entry;
7a292a7a SS	575
	576	/* next victim */
	577	entry = (entry)->next;
	578
c906108c SS	579	while (alias != NULL)
	580	{
	581	sim_memopt *dead = alias;
	582	alias = alias->alias;
	583	sim_core_detach (sd, NULL, dead->level, dead->space, dead->addr);
	584	zfree (dead);
	585	}
c906108c SS	586	}
	587	}
	588
	589
	590	static SIM_RC
	591	sim_memory_init (SIM_DESC sd)
	592	{
764f1408 FCE	593	/* Reinitialize option modifier flags, in case they were left
	594	over from a previous sim startup event. */
	595	fill_byte_flag = 0;
	596	mmap_next_fd = -1;
	597
c906108c SS	598	return SIM_RC_OK;
c906108c SS	599	}