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

/* Simulator memory option handling.
   Copyright (C) 1996-2021 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 "config.h"

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

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