mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-04 07:44:22 +08:00
936df7568a
The common subdir sets up a cconfig.h file to hold checks for the common code. In practice, most files still end up using config.h instead which just leads to confusion. Merge all the configure checks that went into cconfig.h into SIM_AC_COMMON so we can drop the cconfig.h file altogether. Now there is only a single config.h file like normal.
662 lines
16 KiB
C
662 lines
16 KiB
C
/* Simulator memory option handling.
|
|
Copyright (C) 1996-2016 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"
|
|
|
|
#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;
|
|
}
|