mirror/binutils-gdb
2
0
Fork 0
mirror of https://sourceware.org/git/binutils-gdb.git synced 2024-12-21 04:42:53 +08:00
Code Issues Packages Projects Releases Wiki Activity
11010f5a82
binutils-gdb/sim/common/sim-memopt.c
Andrew Cagney bf96209254 * sim-memopt.c: Include <unistd.h>. 
(do_memopt_add): Fix printf format.
* sim-events.c (sim_events_schedule): Initialize ``dummy''.
2002-06-17 21:45:55 +00:00

583 lines
14 KiB
C
Raw Blame History

/* Simulator memory option handling.
Copyright (C) 1996-1999 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.
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. */
#include "cconfig.h"
#include "sim-main.h"
#include "sim-assert.h"
#include "sim-options.h"
#ifdef HAVE_STRING_H
#include <string.h>
#else
#ifdef HAVE_STRINGS_H
#include <strings.h>
#endif
#endif
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_ERRNO_H
#include <errno.h>
#endif
#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif
#ifdef HAVE_SYS_MMAN_H
#include <sys/mman.h>
#endif
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
/* Memory fill byte. */
static unsigned8 fill_byte_value;
static int fill_byte_flag = 0;
/* Memory mapping; see OPTION_MEMORY_MAPFILE. */
static int mmap_next_fd = -1;
/* Memory command line options. */
enum {
OPTION_MEMORY_DELETE = OPTION_START,
OPTION_MEMORY_REGION,
OPTION_MEMORY_SIZE,
OPTION_MEMORY_INFO,
OPTION_MEMORY_ALIAS,
OPTION_MEMORY_CLEAR,
OPTION_MEMORY_FILL,
OPTION_MEMORY_MAPFILE
};
static DECLARE_OPTION_HANDLER (memory_option_handler);
static const OPTION memory_options[] =
{
{ {"memory-delete", required_argument, NULL, OPTION_MEMORY_DELETE },
'\0', "ADDRESS|all", "Delete memory at ADDRESS (all addresses)",
memory_option_handler },
{ {"delete-memory", required_argument, NULL, OPTION_MEMORY_DELETE },
'\0', "ADDRESS", NULL,
memory_option_handler },
{ {"memory-region", required_argument, NULL, OPTION_MEMORY_REGION },
'\0', "ADDRESS,SIZE[,MODULO]", "Add a memory region",
memory_option_handler },
{ {"memory-alias", required_argument, NULL, OPTION_MEMORY_ALIAS },
'\0', "ADDRESS,SIZE{,ADDRESS}", "Add memory shadow",
memory_option_handler },
{ {"memory-size", required_argument, NULL, OPTION_MEMORY_SIZE },
'\0', "SIZE", "Add memory at address zero",
memory_option_handler },
{ {"memory-fill", required_argument, NULL, OPTION_MEMORY_FILL },
'\0', "VALUE", "Fill subsequently added memory regions",
memory_option_handler },
{ {"memory-clear", no_argument, NULL, OPTION_MEMORY_CLEAR },
'\0', NULL, "Clear subsequently added memory regions",
memory_option_handler },
#if defined(HAVE_MMAP) && defined(HAVE_MUNMAP)
{ {"memory-mapfile", required_argument, NULL, OPTION_MEMORY_MAPFILE },
'\0', "FILE", "Memory-map next memory region from file",
memory_option_handler },
#endif
{ {"memory-info", no_argument, NULL, OPTION_MEMORY_INFO },
'\0', NULL, "List configurable memory regions",
memory_option_handler },
{ {"info-memory", no_argument, NULL, OPTION_MEMORY_INFO },
'\0', NULL, NULL,
memory_option_handler },
{ {NULL, no_argument, NULL, 0}, '\0', NULL, NULL, NULL }
};
static sim_memopt *
do_memopt_add (SIM_DESC sd,
int level,
int space,
address_word addr,
address_word nr_bytes,
unsigned modulo,
sim_memopt **entry,
void *buffer)
{
void *fill_buffer;
unsigned fill_length;
void *free_buffer;
unsigned long free_length;
if (buffer != NULL)
{
/* Buffer already given. sim_memory_uninstall will free it. */
sim_core_attach (sd, NULL,
level, access_read_write_exec, space,
addr, nr_bytes, modulo, NULL, buffer);
free_buffer = buffer;
free_length = 0;
fill_buffer = buffer;
fill_length = (modulo == 0) ? nr_bytes : modulo;
}
else
{
/* Allocate new well-aligned buffer, just as sim_core_attach(). */
void *aligned_buffer;
int padding = (addr % sizeof (unsigned64));
unsigned long bytes = (modulo == 0 ? nr_bytes : modulo) + padding;
free_buffer = NULL;
free_length = bytes;
#ifdef HAVE_MMAP
/* Memory map or malloc(). */
if (mmap_next_fd >= 0)
{
/* Check that given file is big enough. */
struct stat s;
int rc;
/* Some kernels will SIGBUS the application if mmap'd file
is not large enough. */
rc = fstat (mmap_next_fd, &s);
if (rc < 0 || s.st_size < bytes)
{
sim_io_error (sd,
"Error, cannot confirm that mmap file is large enough "
"(>= %ld bytes)\n", bytes);
}
free_buffer = mmap (0, bytes, PROT_READ|PROT_WRITE, MAP_SHARED, mmap_next_fd, 0);
if (free_buffer == 0 || free_buffer == (char*)-1) /* MAP_FAILED */
{
sim_io_error (sd, "Error, cannot mmap file (%s).\n",
strerror(errno));
}
}
#endif
/* Need heap allocation? */
if (free_buffer == NULL)
{
/* If filling with non-zero value, do not use clearing allocator. */
if (fill_byte_flag && fill_byte_value != 0)
free_buffer = xmalloc (bytes); /* don't clear */
else
free_buffer = zalloc (bytes); /* clear */
}
aligned_buffer = (char*) free_buffer + padding;
sim_core_attach (sd, NULL,
level, access_read_write_exec, space,
addr, nr_bytes, modulo, NULL, aligned_buffer);
fill_buffer = aligned_buffer;
fill_length = (modulo == 0) ? nr_bytes : modulo;
/* If we just used a clearing allocator, and are about to fill with
zero, truncate the redundant fill operation. */
if (fill_byte_flag && fill_byte_value == 0)
fill_length = 1; /* avoid boundary length=0 case */
}
if (fill_byte_flag)
{
ASSERT (fill_buffer != 0);
memset ((char*) fill_buffer, fill_byte_value, fill_length);
}
while ((*entry) != NULL)
entry = &(*entry)->next;
(*entry) = ZALLOC (sim_memopt);
(*entry)->level = level;
(*entry)->space = space;
(*entry)->addr = addr;
(*entry)->nr_bytes = nr_bytes;
(*entry)->modulo = modulo;
(*entry)->buffer = free_buffer;
/* Record memory unmapping info. */
if (mmap_next_fd >= 0)
{
(*entry)->munmap_length = free_length;
close (mmap_next_fd);
mmap_next_fd = -1;
}
else
(*entry)->munmap_length = 0;
return (*entry);
}
static SIM_RC
do_memopt_delete (SIM_DESC sd,
int level,
int space,
address_word addr)
{
sim_memopt **entry = &STATE_MEMOPT (sd);
sim_memopt *alias;
while ((*entry) != NULL
&& ((*entry)->level != level
|| (*entry)->space != space
|| (*entry)->addr != addr))
entry = &(*entry)->next;
if ((*entry) == NULL)
{
sim_io_eprintf (sd, "Memory at 0x%lx not found, not deleted\n",
(long) addr);
return SIM_RC_FAIL;
}
/* delete any buffer */
if ((*entry)->buffer != NULL)
{
#ifdef HAVE_MUNMAP
if ((*entry)->munmap_length > 0)
munmap ((*entry)->buffer, (*entry)->munmap_length);
else
#endif
zfree ((*entry)->buffer);
}
/* delete it and its aliases */
alias = *entry;
*entry = (*entry)->next;
while (alias != NULL)
{
sim_memopt *dead = alias;
alias = alias->alias;
sim_core_detach (sd, NULL, dead->level, dead->space, dead->addr);
zfree (dead);
}
return SIM_RC_OK;
}
static char *
parse_size (char *chp,
address_word *nr_bytes,
unsigned *modulo)
{
/* <nr_bytes> [ "%" <modulo> ] */
*nr_bytes = strtoul (chp, &chp, 0);
if (*chp == '%')
{
*modulo = strtoul (chp + 1, &chp, 0);
}
return chp;
}
static char *
parse_ulong_value (char *chp,
unsigned long *value)
{
*value = strtoul (chp, &chp, 0);
return chp;
}
static char *
parse_addr (char *chp,
int *level,
int *space,
address_word *addr)
{
/* [ <space> ": " ] <addr> [ "@" <level> ] */
*addr = (unsigned long) strtoul (chp, &chp, 0);
if (*chp == ':')
{
*space = *addr;
*addr = (unsigned long) strtoul (chp + 1, &chp, 0);
}
if (*chp == '@')
{
*level = strtoul (chp + 1, &chp, 0);
}
return chp;
}
static SIM_RC
memory_option_handler (SIM_DESC sd, sim_cpu *cpu, int opt,
char *arg, int is_command)
{
switch (opt)
{
case OPTION_MEMORY_DELETE:
if (strcasecmp (arg, "all") == 0)
{
while (STATE_MEMOPT (sd) != NULL)
do_memopt_delete (sd,
STATE_MEMOPT (sd)->level,
STATE_MEMOPT (sd)->space,
STATE_MEMOPT (sd)->addr);
return SIM_RC_OK;
}
else
{
int level = 0;
int space = 0;
address_word addr = 0;
parse_addr (arg, &level, &space, &addr);
return do_memopt_delete (sd, level, space, addr);
}
case OPTION_MEMORY_REGION:
{
char *chp = arg;
int level = 0;
int space = 0;
address_word addr = 0;
address_word nr_bytes = 0;
unsigned modulo = 0;
/* parse the arguments */
chp = parse_addr (chp, &level, &space, &addr);
if (*chp != ',')
{
sim_io_eprintf (sd, "Missing size for memory-region\n");
return SIM_RC_FAIL;
}
chp = parse_size (chp + 1, &nr_bytes, &modulo);
/* old style */
if (*chp == ',')
modulo = strtoul (chp + 1, &chp, 0);
/* try to attach/insert it */
do_memopt_add (sd, level, space, addr, nr_bytes, modulo,
&STATE_MEMOPT (sd), NULL);
return SIM_RC_OK;
}
case OPTION_MEMORY_ALIAS:
{
char *chp = arg;
int level = 0;
int space = 0;
address_word addr = 0;
address_word nr_bytes = 0;
unsigned modulo = 0;
sim_memopt *entry;
/* parse the arguments */
chp = parse_addr (chp, &level, &space, &addr);
if (*chp != ',')
{
sim_io_eprintf (sd, "Missing size for memory-region\n");
return SIM_RC_FAIL;
}
chp = parse_size (chp + 1, &nr_bytes, &modulo);
/* try to attach/insert the main record */
entry = do_memopt_add (sd, level, space, addr, nr_bytes, modulo,
&STATE_MEMOPT (sd),
NULL);
/* now attach all the aliases */
while (*chp == ',')
{
int a_level = level;
int a_space = space;
address_word a_addr = addr;
chp = parse_addr (chp + 1, &a_level, &a_space, &a_addr);
do_memopt_add (sd, a_level, a_space, a_addr, nr_bytes, modulo,
&entry->alias, entry->buffer);
}
return SIM_RC_OK;
}
case OPTION_MEMORY_SIZE:
{
int level = 0;
int space = 0;
address_word addr = 0;
address_word nr_bytes = 0;
unsigned modulo = 0;
/* parse the arguments */
parse_size (arg, &nr_bytes, &modulo);
/* try to attach/insert it */
do_memopt_add (sd, level, space, addr, nr_bytes, modulo,
&STATE_MEMOPT (sd), NULL);
return SIM_RC_OK;
}
case OPTION_MEMORY_CLEAR:
{
fill_byte_value = (unsigned8) 0;
fill_byte_flag = 1;
return SIM_RC_OK;
break;
}
case OPTION_MEMORY_FILL:
{
unsigned long fill_value;
parse_ulong_value (arg, &fill_value);
if (fill_value > 255)
{
sim_io_eprintf (sd, "Missing fill value between 0 and 255\n");
return SIM_RC_FAIL;
}
fill_byte_value = (unsigned8) fill_value;
fill_byte_flag = 1;
return SIM_RC_OK;
break;
}
case OPTION_MEMORY_MAPFILE:
{
if (mmap_next_fd >= 0)
{
sim_io_eprintf (sd, "Duplicate memory-mapfile option\n");
return SIM_RC_FAIL;
}
mmap_next_fd = open (arg, O_RDWR);
if (mmap_next_fd < 0)
{
sim_io_eprintf (sd, "Cannot open file `%s': %s\n",
arg, strerror(errno));
return SIM_RC_FAIL;
}
return SIM_RC_OK;
}
case OPTION_MEMORY_INFO:
{
sim_memopt *entry;
sim_io_printf (sd, "Memory maps:\n");
for (entry = STATE_MEMOPT (sd); entry != NULL; entry = entry->next)
{
sim_memopt *alias;
sim_io_printf (sd, " memory");
if (entry->alias == NULL)
sim_io_printf (sd, " region ");
else
sim_io_printf (sd, " alias ");
if (entry->space != 0)
sim_io_printf (sd, "0x%lx:", (long) entry->space);
sim_io_printf (sd, "0x%08lx", (long) entry->addr);
if (entry->level != 0)
sim_io_printf (sd, "@0x%lx", (long) entry->level);
sim_io_printf (sd, ",0x%lx",
(long) entry->nr_bytes);
if (entry->modulo != 0)
sim_io_printf (sd, "%%0x%lx", (long) entry->modulo);
for (alias = entry->alias;
alias != NULL;
alias = alias->next)
{
if (alias->space != 0)
sim_io_printf (sd, "0x%lx:", (long) alias->space);
sim_io_printf (sd, ",0x%08lx", (long) alias->addr);
if (alias->level != 0)
sim_io_printf (sd, "@0x%lx", (long) alias->level);
}
sim_io_printf (sd, "\n");
}
return SIM_RC_OK;
break;
}
default:
sim_io_eprintf (sd, "Unknown memory option %d\n", opt);
return SIM_RC_FAIL;
}
return SIM_RC_FAIL;
}
/* "memory" module install handler.
This is called via sim_module_install to install the "memory" subsystem
into the simulator. */
static MODULE_INIT_FN sim_memory_init;
static MODULE_UNINSTALL_FN sim_memory_uninstall;
SIM_RC
sim_memopt_install (SIM_DESC sd)
{
SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
sim_add_option_table (sd, NULL, memory_options);
sim_module_add_uninstall_fn (sd, sim_memory_uninstall);
sim_module_add_init_fn (sd, sim_memory_init);
return SIM_RC_OK;
}
/* Uninstall the "memory" subsystem from the simulator. */
static void
sim_memory_uninstall (SIM_DESC sd)
{
sim_memopt **entry = &STATE_MEMOPT (sd);
sim_memopt *alias;
while ((*entry) != NULL)
{
/* delete any buffer */
if ((*entry)->buffer != NULL)
{
#ifdef HAVE_MUNMAP
if ((*entry)->munmap_length > 0)
munmap ((*entry)->buffer, (*entry)->munmap_length);
else
#endif
zfree ((*entry)->buffer);
}
/* delete it and its aliases */
alias = *entry;
/* next victim */
*entry = (*entry)->next;
while (alias != NULL)
{
sim_memopt *dead = alias;
alias = alias->alias;
sim_core_detach (sd, NULL, dead->level, dead->space, dead->addr);
zfree (dead);
}
}
}
static SIM_RC
sim_memory_init (SIM_DESC sd)
{
/* Reinitialize option modifier flags, in case they were left
over from a previous sim startup event. */
fill_byte_flag = 0;
mmap_next_fd = -1;
return SIM_RC_OK;
}
Reference in New Issue View Git Blame Copy Permalink