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

/* Simulator memory option handling.
   Copyright (C) 1996-2014 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,
  OPTION_MAP_INFO
};

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 },
  { {"map-info", no_argument, NULL, OPTION_MAP_INFO },
      '\0', NULL, "List mapped regions",
      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;

#ifdef HAVE_MMAP
      struct stat s;

      if (mmap_next_fd >= 0)
	{
	  /* Check that given file is big enough. */
	  int rc = fstat (mmap_next_fd, &s);

	  if (rc < 0)
	    sim_io_error (sd, "Error, unable to stat file: %s\n",
			  strerror (errno));

	  /* Autosize the mapping to the file length.  */
	  if (nr_bytes == 0)
	    nr_bytes = s.st_size;
	}
#endif

      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)
	{
	  /* Some kernels will SIGBUS the application if mmap'd file
	     is not large enough.  */
	  if (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
	free ((*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);
      free (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 != ',')
	  {
	    /* let the file autosize */
	    if (mmap_next_fd == -1)
	      {
		sim_io_eprintf (sd, "Missing size for memory-region\n");
		return SIM_RC_FAIL;
	      }
	  }
	else
	  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;
      }

    case OPTION_MAP_INFO:
      {
	sim_core *memory = STATE_CORE (sd);
	unsigned nr_map;

	for (nr_map = 0; nr_map < nr_maps; ++nr_map)
	  {
	    sim_core_map *map = &memory->common.map[nr_map];
	    sim_core_mapping *mapping = map->first;

	    if (!mapping)
	      continue;

	    sim_io_printf (sd, "%s maps:\n", map_to_str (nr_map));
	    do
	      {
		unsigned modulo;

		sim_io_printf (sd, " map ");
		if (mapping->space != 0)
		  sim_io_printf (sd, "0x%x:", mapping->space);
		sim_io_printf (sd, "0x%08lx", (long) mapping->base);
		if (mapping->level != 0)
		  sim_io_printf (sd, "@0x%x", mapping->level);
		sim_io_printf (sd, ",0x%lx", (long) mapping->nr_bytes);
		modulo = mapping->mask + 1;
		if (modulo != 0)
		  sim_io_printf (sd, "%%0x%x", modulo);
		sim_io_printf (sd, "\n");

		mapping = mapping->next;
	      }
	    while (mapping);
	  }

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