/* Simulator memory option handling.
- Copyright (C) 1996, 1997 Free Software Foundation, Inc.
+ Copyright (C) 1996-1999, 2007, 2008, 2009, 2010, 2011
+ 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 2, or (at your option)
-any later version.
+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, write to the Free Software Foundation, Inc.,
-59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+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"
#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;
-/* "core" command line options. */
+/* Memory mapping; see OPTION_MEMORY_MAPFILE. */
+static int mmap_next_fd = -1;
+
+/* Memory command line options. */
enum {
OPTION_MEMORY_DELETE = OPTION_START,
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", "Delete memory at ADDRESS",
+ '\0', "ADDRESS", NULL,
memory_option_handler },
{ {"memory-region", required_argument, NULL, OPTION_MEMORY_REGION },
memory_option_handler },
{ {"memory-size", required_argument, NULL, OPTION_MEMORY_SIZE },
- '\0', "SIZE", "Add memory at address zero",
+ '\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 all memory regions",
+ '\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, "Add memory at address zero",
+ '\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
-memory_option_handler (sd, opt, arg, is_command)
- SIM_DESC sd;
- int opt;
- char *arg;
- int is_command;
+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:
{
- address_word addr = strtoul (arg, NULL, 0);
- sim_memopt **entry = &STATE_MEMOPT (sd);
- sim_memopt *alias;
- while ((*entry) != NULL && (*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)->buf != NULL)
- zfree ((*entry)->buf);
- /* delete it and its aliases */
- alias = *entry;
- *entry = alias->next;
- while (alias != NULL)
+ 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_memopt *dead = alias;
- alias = alias->alias;
- sim_core_detach (sd, NULL, attach_raw_memory, 0, dead->addr);
- zfree (dead);
+ /* 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_REGION:
+
+ 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 = &STATE_MEMOPT (sd);
+ sim_memopt *entry;
/* parse the arguments */
- addr = strtoul (chp, &chp, 0);
+ chp = parse_addr (chp, &level, &space, &addr);
if (*chp != ',')
{
sim_io_eprintf (sd, "Missing size for memory-region\n");
return SIM_RC_FAIL;
}
- chp++;
- nr_bytes = strtoul (chp, &chp, 0);
- if (*chp == ',')
- modulo = strtoul (chp + 1, NULL, 0);
- /* try to attach it */
- sim_core_attach (sd, NULL,
- attach_raw_memory, access_read_write_exec, 0,
- addr, nr_bytes, modulo, NULL, NULL);
- /* ok, so insert it */
- while ((*entry) != NULL)
- entry = &(*entry)->next;
- (*entry) = ZALLOC (sim_memopt);
- (*entry)->addr = addr;
- (*entry)->nr_bytes = nr_bytes;
- (*entry)->modulo = modulo;
+ 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_ALIAS:
+ case OPTION_MEMORY_SIZE:
{
- sim_io_eprintf (sd, "memory-alias not supported for for this simulator\n");
- break;
+ 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_SIZE:
+ case OPTION_MEMORY_CLEAR:
{
- sim_io_eprintf (sd, "memory-size not supported for for this simulator\n");
- return SIM_RC_FAIL;
+ fill_byte_value = (unsigned8) 0;
+ fill_byte_flag = 1;
+ return SIM_RC_OK;
break;
}
- case OPTION_MEMORY_CLEAR:
+ case OPTION_MEMORY_FILL:
{
- sim_memopt *entry;
- for (entry = STATE_MEMOPT (sd); entry != NULL; entry = entry->next)
+ unsigned long fill_value;
+ parse_ulong_value (arg, &fill_value);
+ if (fill_value > 255)
{
- sim_memopt *alias;
- for (alias = entry; alias != NULL; alias = alias->next)
- {
- unsigned8 zero = 0;
- address_word nr_bytes;
- if (alias->modulo != 0)
- nr_bytes = alias->modulo;
- else
- nr_bytes = alias->nr_bytes;
- sim_core_write_buffer (sd, NULL, sim_core_write_map,
- &zero,
- alias->addr + nr_bytes,
- sizeof (zero));
-
- }
+ 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_memopt *alias;
sim_io_printf (sd, " memory");
if (entry->alias == NULL)
- {
- sim_io_printf (sd, " region 0x%08lx,0x%lx",
- (long) entry->addr,
- (long) entry->nr_bytes);
- if (entry->modulo != 0)
- sim_io_printf (sd, ",0x%lx", (long) entry->modulo);
- }
+ 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)
{
- sim_io_printf (sd, " alias 0x%08lx,0x%lx",
- (long) entry->addr,
- (long) entry->nr_bytes);
- for (alias = entry->alias; alias != NULL; alias = alias->next)
- sim_io_printf (sd, ",0x%08lx", entry->addr);
+ 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");
}
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 watch option %d\n", opt);
+ sim_io_eprintf (sd, "Unknown memory option %d\n", opt);
return SIM_RC_FAIL;
}
sim_memopt_install (SIM_DESC sd)
{
SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
- sim_add_option_table (sd, memory_options);
+ 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;
static void
sim_memory_uninstall (SIM_DESC sd)
{
- /* FIXME: free buffers, etc. */
+ 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)
{
- /* FIXME: anything needed? */
+ /* 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;
}
projects / external / binutils.git / blobdiff