/* Main simulator entry points specific to the CRIS.
|
/* Main simulator entry points specific to the CRIS.
|
Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010
|
Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
Contributed by Axis Communications.
|
Contributed by Axis Communications.
|
|
|
This file is part of the GNU simulators.
|
This file is part of the GNU simulators.
|
|
|
This program is free software; you can redistribute it and/or modify
|
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
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 3 of the License, or
|
the Free Software Foundation; either version 3 of the License, or
|
(at your option) any later version.
|
(at your option) any later version.
|
|
|
This program is distributed in the hope that it will be useful,
|
This program is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
/* Based on the fr30 file, mixing in bits from the i960 and pruning of
|
/* Based on the fr30 file, mixing in bits from the i960 and pruning of
|
dead code. */
|
dead code. */
|
|
|
#include "libiberty.h"
|
#include "libiberty.h"
|
#include "bfd.h"
|
#include "bfd.h"
|
#include "elf-bfd.h"
|
#include "elf-bfd.h"
|
|
|
#include "sim-main.h"
|
#include "sim-main.h"
|
#ifdef HAVE_STDLIB_H
|
#ifdef HAVE_STDLIB_H
|
#include <stdlib.h>
|
#include <stdlib.h>
|
#endif
|
#endif
|
#include <errno.h>
|
#include <errno.h>
|
#include "sim-options.h"
|
#include "sim-options.h"
|
#include "dis-asm.h"
|
#include "dis-asm.h"
|
|
|
/* Apparently the autoconf bits are missing (though HAVE_ENVIRON is used
|
/* Apparently the autoconf bits are missing (though HAVE_ENVIRON is used
|
in other dirs; also lacking there). Patch around it for major systems. */
|
in other dirs; also lacking there). Patch around it for major systems. */
|
#if defined (HAVE_ENVIRON) || defined (__GLIBC__)
|
#if defined (HAVE_ENVIRON) || defined (__GLIBC__)
|
extern char **environ;
|
extern char **environ;
|
#define GET_ENVIRON() environ
|
#define GET_ENVIRON() environ
|
#else
|
#else
|
char *missing_environ[] = { "SHELL=/bin/sh", "PATH=/bin:/usr/bin", NULL };
|
char *missing_environ[] = { "SHELL=/bin/sh", "PATH=/bin:/usr/bin", NULL };
|
#define GET_ENVIRON() missing_environ
|
#define GET_ENVIRON() missing_environ
|
#endif
|
#endif
|
|
|
/* Used with get_progbounds to find out how much memory is needed for the
|
/* Used with get_progbounds to find out how much memory is needed for the
|
program. We don't want to allocate more, since that could mask
|
program. We don't want to allocate more, since that could mask
|
invalid memory accesses program bugs. */
|
invalid memory accesses program bugs. */
|
struct progbounds {
|
struct progbounds {
|
USI startmem;
|
USI startmem;
|
USI endmem;
|
USI endmem;
|
USI end_loadmem;
|
USI end_loadmem;
|
USI start_nonloadmem;
|
USI start_nonloadmem;
|
};
|
};
|
|
|
static void free_state (SIM_DESC);
|
static void free_state (SIM_DESC);
|
static void get_progbounds_iterator (bfd *, asection *, void *);
|
static void get_progbounds_iterator (bfd *, asection *, void *);
|
static SIM_RC cris_option_handler (SIM_DESC, sim_cpu *, int, char *, int);
|
static SIM_RC cris_option_handler (SIM_DESC, sim_cpu *, int, char *, int);
|
|
|
/* Since we don't build the cgen-opcode table, we use the old
|
/* Since we don't build the cgen-opcode table, we use the old
|
disassembler. */
|
disassembler. */
|
static CGEN_DISASSEMBLER cris_disassemble_insn;
|
static CGEN_DISASSEMBLER cris_disassemble_insn;
|
|
|
/* By default, we set up stack and environment variables like the Linux
|
/* By default, we set up stack and environment variables like the Linux
|
kernel. */
|
kernel. */
|
static char cris_bare_iron = 0;
|
static char cris_bare_iron = 0;
|
|
|
/* Whether 0x9000000xx have simulator-specific meanings. */
|
/* Whether 0x9000000xx have simulator-specific meanings. */
|
char cris_have_900000xxif = 0;
|
char cris_have_900000xxif = 0;
|
|
|
/* Used to optionally override the default start address of the
|
/* Used to optionally override the default start address of the
|
simulation. */
|
simulation. */
|
static USI cris_start_address = 0xffffffffu;
|
static USI cris_start_address = 0xffffffffu;
|
|
|
/* Used to optionally add offsets to the loaded image and its start
|
/* Used to optionally add offsets to the loaded image and its start
|
address. (Not used for the interpreter of dynamically loaded
|
address. (Not used for the interpreter of dynamically loaded
|
programs or the DSO:s.) */
|
programs or the DSO:s.) */
|
static int cris_program_offset = 0;
|
static int cris_program_offset = 0;
|
|
|
/* What to do when we face a more or less unknown syscall. */
|
/* What to do when we face a more or less unknown syscall. */
|
enum cris_unknown_syscall_action_type cris_unknown_syscall_action
|
enum cris_unknown_syscall_action_type cris_unknown_syscall_action
|
= CRIS_USYSC_MSG_STOP;
|
= CRIS_USYSC_MSG_STOP;
|
|
|
/* Records simulator descriptor so utilities like cris_dump_regs can be
|
/* Records simulator descriptor so utilities like cris_dump_regs can be
|
called from gdb. */
|
called from gdb. */
|
SIM_DESC current_state;
|
SIM_DESC current_state;
|
|
|
/* CRIS-specific options. */
|
/* CRIS-specific options. */
|
typedef enum {
|
typedef enum {
|
OPTION_CRIS_STATS = OPTION_START,
|
OPTION_CRIS_STATS = OPTION_START,
|
OPTION_CRIS_TRACE,
|
OPTION_CRIS_TRACE,
|
OPTION_CRIS_NAKED,
|
OPTION_CRIS_NAKED,
|
OPTION_CRIS_PROGRAM_OFFSET,
|
OPTION_CRIS_PROGRAM_OFFSET,
|
OPTION_CRIS_STARTADDR,
|
OPTION_CRIS_STARTADDR,
|
OPTION_CRIS_900000XXIF,
|
OPTION_CRIS_900000XXIF,
|
OPTION_CRIS_UNKNOWN_SYSCALL
|
OPTION_CRIS_UNKNOWN_SYSCALL
|
} CRIS_OPTIONS;
|
} CRIS_OPTIONS;
|
|
|
static const OPTION cris_options[] =
|
static const OPTION cris_options[] =
|
{
|
{
|
{ {"cris-cycles", required_argument, NULL, OPTION_CRIS_STATS},
|
{ {"cris-cycles", required_argument, NULL, OPTION_CRIS_STATS},
|
'\0', "basic|unaligned|schedulable|all",
|
'\0', "basic|unaligned|schedulable|all",
|
"Dump execution statistics",
|
"Dump execution statistics",
|
cris_option_handler, NULL },
|
cris_option_handler, NULL },
|
{ {"cris-trace", required_argument, NULL, OPTION_CRIS_TRACE},
|
{ {"cris-trace", required_argument, NULL, OPTION_CRIS_TRACE},
|
'\0', "basic",
|
'\0', "basic",
|
"Emit trace information while running",
|
"Emit trace information while running",
|
cris_option_handler, NULL },
|
cris_option_handler, NULL },
|
{ {"cris-naked", no_argument, NULL, OPTION_CRIS_NAKED},
|
{ {"cris-naked", no_argument, NULL, OPTION_CRIS_NAKED},
|
'\0', NULL, "Don't set up stack and environment",
|
'\0', NULL, "Don't set up stack and environment",
|
cris_option_handler, NULL },
|
cris_option_handler, NULL },
|
{ {"cris-900000xx", no_argument, NULL, OPTION_CRIS_900000XXIF},
|
{ {"cris-900000xx", no_argument, NULL, OPTION_CRIS_900000XXIF},
|
'\0', NULL, "Define addresses at 0x900000xx with simulator semantics",
|
'\0', NULL, "Define addresses at 0x900000xx with simulator semantics",
|
cris_option_handler, NULL },
|
cris_option_handler, NULL },
|
{ {"cris-unknown-syscall", required_argument, NULL,
|
{ {"cris-unknown-syscall", required_argument, NULL,
|
OPTION_CRIS_UNKNOWN_SYSCALL},
|
OPTION_CRIS_UNKNOWN_SYSCALL},
|
'\0', "stop|enosys|enosys-quiet", "Action at an unknown system call",
|
'\0', "stop|enosys|enosys-quiet", "Action at an unknown system call",
|
cris_option_handler, NULL },
|
cris_option_handler, NULL },
|
{ {"cris-program-offset", required_argument, NULL,
|
{ {"cris-program-offset", required_argument, NULL,
|
OPTION_CRIS_PROGRAM_OFFSET},
|
OPTION_CRIS_PROGRAM_OFFSET},
|
'\0', "OFFSET",
|
'\0', "OFFSET",
|
"Offset image addresses and default start address of a program",
|
"Offset image addresses and default start address of a program",
|
cris_option_handler },
|
cris_option_handler },
|
{ {"cris-start-address", required_argument, NULL, OPTION_CRIS_STARTADDR},
|
{ {"cris-start-address", required_argument, NULL, OPTION_CRIS_STARTADDR},
|
'\0', "ADDRESS", "Set start address",
|
'\0', "ADDRESS", "Set start address",
|
cris_option_handler },
|
cris_option_handler },
|
{ {NULL, no_argument, NULL, 0}, '\0', NULL, NULL, NULL, NULL }
|
{ {NULL, no_argument, NULL, 0}, '\0', NULL, NULL, NULL, NULL }
|
};
|
};
|
|
|
/* Add the CRIS-specific option list to the simulator. */
|
/* Add the CRIS-specific option list to the simulator. */
|
|
|
SIM_RC
|
SIM_RC
|
cris_option_install (SIM_DESC sd)
|
cris_option_install (SIM_DESC sd)
|
{
|
{
|
SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
|
SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
|
if (sim_add_option_table (sd, NULL, cris_options) != SIM_RC_OK)
|
if (sim_add_option_table (sd, NULL, cris_options) != SIM_RC_OK)
|
return SIM_RC_FAIL;
|
return SIM_RC_FAIL;
|
return SIM_RC_OK;
|
return SIM_RC_OK;
|
}
|
}
|
|
|
/* Handle CRIS-specific options. */
|
/* Handle CRIS-specific options. */
|
|
|
static SIM_RC
|
static SIM_RC
|
cris_option_handler (SIM_DESC sd, sim_cpu *cpu ATTRIBUTE_UNUSED, int opt,
|
cris_option_handler (SIM_DESC sd, sim_cpu *cpu ATTRIBUTE_UNUSED, int opt,
|
char *arg, int is_command ATTRIBUTE_UNUSED)
|
char *arg, int is_command ATTRIBUTE_UNUSED)
|
{
|
{
|
/* The options are CRIS-specific, but cpu-specific option-handling is
|
/* The options are CRIS-specific, but cpu-specific option-handling is
|
broken; required to being with "--cpu0-". We store the flags in an
|
broken; required to being with "--cpu0-". We store the flags in an
|
unused field in the global state structure and move the flags over
|
unused field in the global state structure and move the flags over
|
to the module-specific CPU data when we store things in the
|
to the module-specific CPU data when we store things in the
|
cpu-specific structure. */
|
cpu-specific structure. */
|
char *tracefp = STATE_TRACE_FLAGS (sd);
|
char *tracefp = STATE_TRACE_FLAGS (sd);
|
char *chp = arg;
|
char *chp = arg;
|
|
|
switch ((CRIS_OPTIONS) opt)
|
switch ((CRIS_OPTIONS) opt)
|
{
|
{
|
case OPTION_CRIS_STATS:
|
case OPTION_CRIS_STATS:
|
if (strcmp (arg, "basic") == 0)
|
if (strcmp (arg, "basic") == 0)
|
*tracefp = FLAG_CRIS_MISC_PROFILE_SIMPLE;
|
*tracefp = FLAG_CRIS_MISC_PROFILE_SIMPLE;
|
else if (strcmp (arg, "unaligned") == 0)
|
else if (strcmp (arg, "unaligned") == 0)
|
*tracefp
|
*tracefp
|
= (FLAG_CRIS_MISC_PROFILE_UNALIGNED
|
= (FLAG_CRIS_MISC_PROFILE_UNALIGNED
|
| FLAG_CRIS_MISC_PROFILE_SIMPLE);
|
| FLAG_CRIS_MISC_PROFILE_SIMPLE);
|
else if (strcmp (arg, "schedulable") == 0)
|
else if (strcmp (arg, "schedulable") == 0)
|
*tracefp
|
*tracefp
|
= (FLAG_CRIS_MISC_PROFILE_SCHEDULABLE
|
= (FLAG_CRIS_MISC_PROFILE_SCHEDULABLE
|
| FLAG_CRIS_MISC_PROFILE_SIMPLE);
|
| FLAG_CRIS_MISC_PROFILE_SIMPLE);
|
else if (strcmp (arg, "all") == 0)
|
else if (strcmp (arg, "all") == 0)
|
*tracefp = FLAG_CRIS_MISC_PROFILE_ALL;
|
*tracefp = FLAG_CRIS_MISC_PROFILE_ALL;
|
else
|
else
|
{
|
{
|
/* Beware; the framework does not handle the error case;
|
/* Beware; the framework does not handle the error case;
|
we have to do it ourselves. */
|
we have to do it ourselves. */
|
sim_io_eprintf (sd, "Unknown option `--cris-cycles=%s'\n", arg);
|
sim_io_eprintf (sd, "Unknown option `--cris-cycles=%s'\n", arg);
|
return SIM_RC_FAIL;
|
return SIM_RC_FAIL;
|
}
|
}
|
break;
|
break;
|
|
|
case OPTION_CRIS_TRACE:
|
case OPTION_CRIS_TRACE:
|
if (strcmp (arg, "basic") == 0)
|
if (strcmp (arg, "basic") == 0)
|
*tracefp |= FLAG_CRIS_MISC_PROFILE_XSIM_TRACE;
|
*tracefp |= FLAG_CRIS_MISC_PROFILE_XSIM_TRACE;
|
else
|
else
|
{
|
{
|
sim_io_eprintf (sd, "Unknown option `--cris-trace=%s'\n", arg);
|
sim_io_eprintf (sd, "Unknown option `--cris-trace=%s'\n", arg);
|
return SIM_RC_FAIL;
|
return SIM_RC_FAIL;
|
}
|
}
|
break;
|
break;
|
|
|
case OPTION_CRIS_NAKED:
|
case OPTION_CRIS_NAKED:
|
cris_bare_iron = 1;
|
cris_bare_iron = 1;
|
break;
|
break;
|
|
|
case OPTION_CRIS_900000XXIF:
|
case OPTION_CRIS_900000XXIF:
|
cris_have_900000xxif = 1;
|
cris_have_900000xxif = 1;
|
break;
|
break;
|
|
|
case OPTION_CRIS_STARTADDR:
|
case OPTION_CRIS_STARTADDR:
|
errno = 0;
|
errno = 0;
|
cris_start_address = (USI) strtoul (chp, &chp, 0);
|
cris_start_address = (USI) strtoul (chp, &chp, 0);
|
|
|
if (errno != 0 || *chp != 0)
|
if (errno != 0 || *chp != 0)
|
{
|
{
|
sim_io_eprintf (sd, "Invalid option `--cris-start-address=%s'\n",
|
sim_io_eprintf (sd, "Invalid option `--cris-start-address=%s'\n",
|
arg);
|
arg);
|
return SIM_RC_FAIL;
|
return SIM_RC_FAIL;
|
}
|
}
|
break;
|
break;
|
|
|
case OPTION_CRIS_PROGRAM_OFFSET:
|
case OPTION_CRIS_PROGRAM_OFFSET:
|
errno = 0;
|
errno = 0;
|
cris_program_offset = (int) strtol (chp, &chp, 0);
|
cris_program_offset = (int) strtol (chp, &chp, 0);
|
|
|
if (errno != 0 || *chp != 0)
|
if (errno != 0 || *chp != 0)
|
{
|
{
|
sim_io_eprintf (sd, "Invalid option `--cris-program-offset=%s'\n",
|
sim_io_eprintf (sd, "Invalid option `--cris-program-offset=%s'\n",
|
arg);
|
arg);
|
return SIM_RC_FAIL;
|
return SIM_RC_FAIL;
|
}
|
}
|
break;
|
break;
|
|
|
case OPTION_CRIS_UNKNOWN_SYSCALL:
|
case OPTION_CRIS_UNKNOWN_SYSCALL:
|
if (strcmp (arg, "enosys") == 0)
|
if (strcmp (arg, "enosys") == 0)
|
cris_unknown_syscall_action = CRIS_USYSC_MSG_ENOSYS;
|
cris_unknown_syscall_action = CRIS_USYSC_MSG_ENOSYS;
|
else if (strcmp (arg, "enosys-quiet") == 0)
|
else if (strcmp (arg, "enosys-quiet") == 0)
|
cris_unknown_syscall_action = CRIS_USYSC_QUIET_ENOSYS;
|
cris_unknown_syscall_action = CRIS_USYSC_QUIET_ENOSYS;
|
else if (strcmp (arg, "stop") == 0)
|
else if (strcmp (arg, "stop") == 0)
|
cris_unknown_syscall_action = CRIS_USYSC_MSG_STOP;
|
cris_unknown_syscall_action = CRIS_USYSC_MSG_STOP;
|
else
|
else
|
{
|
{
|
sim_io_eprintf (sd, "Unknown option `--cris-unknown-syscall=%s'\n",
|
sim_io_eprintf (sd, "Unknown option `--cris-unknown-syscall=%s'\n",
|
arg);
|
arg);
|
return SIM_RC_FAIL;
|
return SIM_RC_FAIL;
|
}
|
}
|
break;
|
break;
|
|
|
default:
|
default:
|
/* We'll actually never get here; the caller handles the error
|
/* We'll actually never get here; the caller handles the error
|
case. */
|
case. */
|
sim_io_eprintf (sd, "Unknown option `%s'\n", arg);
|
sim_io_eprintf (sd, "Unknown option `%s'\n", arg);
|
return SIM_RC_FAIL;
|
return SIM_RC_FAIL;
|
}
|
}
|
|
|
/* Imply --profile-model=on. */
|
/* Imply --profile-model=on. */
|
return sim_profile_set_option (sd, "-model", PROFILE_MODEL_IDX, "on");
|
return sim_profile_set_option (sd, "-model", PROFILE_MODEL_IDX, "on");
|
}
|
}
|
|
|
/* FIXME: Remove these, globalize those in sim-load.c, move elsewhere. */
|
/* FIXME: Remove these, globalize those in sim-load.c, move elsewhere. */
|
|
|
static void
|
static void
|
xprintf (host_callback *callback, const char *fmt, ...)
|
xprintf (host_callback *callback, const char *fmt, ...)
|
{
|
{
|
va_list ap;
|
va_list ap;
|
|
|
va_start (ap, fmt);
|
va_start (ap, fmt);
|
|
|
(*callback->vprintf_filtered) (callback, fmt, ap);
|
(*callback->vprintf_filtered) (callback, fmt, ap);
|
|
|
va_end (ap);
|
va_end (ap);
|
}
|
}
|
|
|
static void
|
static void
|
eprintf (host_callback *callback, const char *fmt, ...)
|
eprintf (host_callback *callback, const char *fmt, ...)
|
{
|
{
|
va_list ap;
|
va_list ap;
|
|
|
va_start (ap, fmt);
|
va_start (ap, fmt);
|
|
|
(*callback->evprintf_filtered) (callback, fmt, ap);
|
(*callback->evprintf_filtered) (callback, fmt, ap);
|
|
|
va_end (ap);
|
va_end (ap);
|
}
|
}
|
|
|
/* An ELF-specific simplified ../common/sim-load.c:sim_load_file,
|
/* An ELF-specific simplified ../common/sim-load.c:sim_load_file,
|
using the program headers, not sections, in order to make sure that
|
using the program headers, not sections, in order to make sure that
|
the program headers themeselves are also loaded. The caller is
|
the program headers themeselves are also loaded. The caller is
|
responsible for asserting that ABFD is an ELF file. */
|
responsible for asserting that ABFD is an ELF file. */
|
|
|
static bfd_boolean
|
static bfd_boolean
|
cris_load_elf_file (SIM_DESC sd, struct bfd *abfd, sim_write_fn do_write)
|
cris_load_elf_file (SIM_DESC sd, struct bfd *abfd, sim_write_fn do_write)
|
{
|
{
|
Elf_Internal_Phdr *phdr;
|
Elf_Internal_Phdr *phdr;
|
int n_hdrs;
|
int n_hdrs;
|
int i;
|
int i;
|
bfd_boolean verbose = STATE_OPEN_KIND (sd) == SIM_OPEN_DEBUG;
|
bfd_boolean verbose = STATE_OPEN_KIND (sd) == SIM_OPEN_DEBUG;
|
host_callback *callback = STATE_CALLBACK (sd);
|
host_callback *callback = STATE_CALLBACK (sd);
|
|
|
phdr = elf_tdata (abfd)->phdr;
|
phdr = elf_tdata (abfd)->phdr;
|
n_hdrs = elf_elfheader (abfd)->e_phnum;
|
n_hdrs = elf_elfheader (abfd)->e_phnum;
|
|
|
/* We're only interested in PT_LOAD; all necessary information
|
/* We're only interested in PT_LOAD; all necessary information
|
should be covered by that. */
|
should be covered by that. */
|
for (i = 0; i < n_hdrs; i++)
|
for (i = 0; i < n_hdrs; i++)
|
{
|
{
|
bfd_byte *buf;
|
bfd_byte *buf;
|
bfd_vma lma = STATE_LOAD_AT_LMA_P (sd)
|
bfd_vma lma = STATE_LOAD_AT_LMA_P (sd)
|
? phdr[i].p_paddr : phdr[i].p_vaddr;
|
? phdr[i].p_paddr : phdr[i].p_vaddr;
|
|
|
if (phdr[i].p_type != PT_LOAD)
|
if (phdr[i].p_type != PT_LOAD)
|
continue;
|
continue;
|
|
|
buf = xmalloc (phdr[i].p_filesz);
|
buf = xmalloc (phdr[i].p_filesz);
|
|
|
if (verbose)
|
if (verbose)
|
xprintf (callback, "Loading segment at 0x%lx, size 0x%lx\n",
|
xprintf (callback, "Loading segment at 0x%lx, size 0x%lx\n",
|
lma, phdr[i].p_filesz);
|
lma, phdr[i].p_filesz);
|
|
|
if (bfd_seek (abfd, phdr[i].p_offset, SEEK_SET) != 0
|
if (bfd_seek (abfd, phdr[i].p_offset, SEEK_SET) != 0
|
|| (bfd_bread (buf, phdr[i].p_filesz, abfd) != phdr[i].p_filesz))
|
|| (bfd_bread (buf, phdr[i].p_filesz, abfd) != phdr[i].p_filesz))
|
{
|
{
|
eprintf (callback,
|
eprintf (callback,
|
"%s: could not read segment at 0x%lx, size 0x%lx\n",
|
"%s: could not read segment at 0x%lx, size 0x%lx\n",
|
STATE_MY_NAME (sd), lma, phdr[i].p_filesz);
|
STATE_MY_NAME (sd), lma, phdr[i].p_filesz);
|
free (buf);
|
free (buf);
|
return FALSE;
|
return FALSE;
|
}
|
}
|
|
|
if (do_write (sd, lma, buf, phdr[i].p_filesz) != phdr[i].p_filesz)
|
if (do_write (sd, lma, buf, phdr[i].p_filesz) != phdr[i].p_filesz)
|
{
|
{
|
eprintf (callback,
|
eprintf (callback,
|
"%s: could not load segment at 0x%lx, size 0x%lx\n",
|
"%s: could not load segment at 0x%lx, size 0x%lx\n",
|
STATE_MY_NAME (sd), lma, phdr[i].p_filesz);
|
STATE_MY_NAME (sd), lma, phdr[i].p_filesz);
|
free (buf);
|
free (buf);
|
return FALSE;
|
return FALSE;
|
}
|
}
|
|
|
free (buf);
|
free (buf);
|
}
|
}
|
|
|
return TRUE;
|
return TRUE;
|
}
|
}
|
|
|
/* Helper for sim_load (needed just for ELF files): like sim_write,
|
/* Helper for sim_load (needed just for ELF files): like sim_write,
|
but offset load at cris_program_offset offset. */
|
but offset load at cris_program_offset offset. */
|
|
|
static int
|
static int
|
cris_program_offset_write (SIM_DESC sd, SIM_ADDR mem, unsigned char *buf,
|
cris_program_offset_write (SIM_DESC sd, SIM_ADDR mem, unsigned char *buf,
|
int length)
|
int length)
|
{
|
{
|
return sim_write (sd, mem + cris_program_offset, buf, length);
|
return sim_write (sd, mem + cris_program_offset, buf, length);
|
}
|
}
|
|
|
/* Replacement for ../common/sim-hload.c:sim_load, so we can treat ELF
|
/* Replacement for ../common/sim-hload.c:sim_load, so we can treat ELF
|
files differently. */
|
files differently. */
|
|
|
SIM_RC
|
SIM_RC
|
sim_load (SIM_DESC sd, char *prog_name, struct bfd *prog_bfd,
|
sim_load (SIM_DESC sd, char *prog_name, struct bfd *prog_bfd,
|
int from_tty ATTRIBUTE_UNUSED)
|
int from_tty ATTRIBUTE_UNUSED)
|
{
|
{
|
bfd *result_bfd;
|
bfd *result_bfd;
|
|
|
if (bfd_get_flavour (prog_bfd) != bfd_target_elf_flavour)
|
if (bfd_get_flavour (prog_bfd) != bfd_target_elf_flavour)
|
{
|
{
|
SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
|
SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
|
if (sim_analyze_program (sd, prog_name, prog_bfd) != SIM_RC_OK)
|
if (sim_analyze_program (sd, prog_name, prog_bfd) != SIM_RC_OK)
|
return SIM_RC_FAIL;
|
return SIM_RC_FAIL;
|
SIM_ASSERT (STATE_PROG_BFD (sd) != NULL);
|
SIM_ASSERT (STATE_PROG_BFD (sd) != NULL);
|
|
|
result_bfd = sim_load_file (sd, STATE_MY_NAME (sd),
|
result_bfd = sim_load_file (sd, STATE_MY_NAME (sd),
|
STATE_CALLBACK (sd),
|
STATE_CALLBACK (sd),
|
prog_name,
|
prog_name,
|
STATE_PROG_BFD (sd),
|
STATE_PROG_BFD (sd),
|
STATE_OPEN_KIND (sd) == SIM_OPEN_DEBUG,
|
STATE_OPEN_KIND (sd) == SIM_OPEN_DEBUG,
|
STATE_LOAD_AT_LMA_P (sd),
|
STATE_LOAD_AT_LMA_P (sd),
|
sim_write);
|
sim_write);
|
if (result_bfd == NULL)
|
if (result_bfd == NULL)
|
{
|
{
|
bfd_close (STATE_PROG_BFD (sd));
|
bfd_close (STATE_PROG_BFD (sd));
|
STATE_PROG_BFD (sd) = NULL;
|
STATE_PROG_BFD (sd) = NULL;
|
return SIM_RC_FAIL;
|
return SIM_RC_FAIL;
|
}
|
}
|
return SIM_RC_OK;
|
return SIM_RC_OK;
|
}
|
}
|
|
|
return cris_load_elf_file (sd, prog_bfd, cris_program_offset_write)
|
return cris_load_elf_file (sd, prog_bfd, cris_program_offset_write)
|
? SIM_RC_OK : SIM_RC_FAIL;
|
? SIM_RC_OK : SIM_RC_FAIL;
|
}
|
}
|
|
|
/* Cover function of sim_state_free to free the cpu buffers as well. */
|
/* Cover function of sim_state_free to free the cpu buffers as well. */
|
|
|
static void
|
static void
|
free_state (SIM_DESC sd)
|
free_state (SIM_DESC sd)
|
{
|
{
|
if (STATE_MODULES (sd) != NULL)
|
if (STATE_MODULES (sd) != NULL)
|
sim_module_uninstall (sd);
|
sim_module_uninstall (sd);
|
sim_cpu_free_all (sd);
|
sim_cpu_free_all (sd);
|
sim_state_free (sd);
|
sim_state_free (sd);
|
}
|
}
|
|
|
/* Helper struct for cris_set_section_offset_iterator. */
|
/* Helper struct for cris_set_section_offset_iterator. */
|
|
|
struct offsetinfo
|
struct offsetinfo
|
{
|
{
|
SIM_DESC sd;
|
SIM_DESC sd;
|
int offset;
|
int offset;
|
};
|
};
|
|
|
/* BFD section iterator to offset the LMA and VMA. */
|
/* BFD section iterator to offset the LMA and VMA. */
|
|
|
static void
|
static void
|
cris_set_section_offset_iterator (bfd *abfd, asection *s, void *vp)
|
cris_set_section_offset_iterator (bfd *abfd, asection *s, void *vp)
|
{
|
{
|
struct offsetinfo *p = (struct offsetinfo *) vp;
|
struct offsetinfo *p = (struct offsetinfo *) vp;
|
SIM_DESC sd = p->sd;
|
SIM_DESC sd = p->sd;
|
int offset = p->offset;
|
int offset = p->offset;
|
|
|
if ((bfd_get_section_flags (abfd, s) & SEC_ALLOC))
|
if ((bfd_get_section_flags (abfd, s) & SEC_ALLOC))
|
{
|
{
|
bfd_vma vma = bfd_get_section_vma (abfd, s);
|
bfd_vma vma = bfd_get_section_vma (abfd, s);
|
|
|
bfd_set_section_vma (abfd, s, vma + offset);
|
bfd_set_section_vma (abfd, s, vma + offset);
|
}
|
}
|
|
|
/* This seems clumsy and inaccurate, but let's stick to doing it the
|
/* This seems clumsy and inaccurate, but let's stick to doing it the
|
same way as sim_analyze_program for consistency. */
|
same way as sim_analyze_program for consistency. */
|
if (strcmp (bfd_get_section_name (abfd, s), ".text") == 0)
|
if (strcmp (bfd_get_section_name (abfd, s), ".text") == 0)
|
STATE_TEXT_START (sd) = bfd_get_section_vma (abfd, s);
|
STATE_TEXT_START (sd) = bfd_get_section_vma (abfd, s);
|
}
|
}
|
|
|
/* Adjust the start-address, LMA and VMA of a SD. Must be called
|
/* Adjust the start-address, LMA and VMA of a SD. Must be called
|
after sim_analyze_program. */
|
after sim_analyze_program. */
|
|
|
static void
|
static void
|
cris_offset_sections (SIM_DESC sd, int offset)
|
cris_offset_sections (SIM_DESC sd, int offset)
|
{
|
{
|
bfd_boolean ret;
|
bfd_boolean ret;
|
struct bfd *abfd = STATE_PROG_BFD (sd);
|
struct bfd *abfd = STATE_PROG_BFD (sd);
|
asection *text;
|
asection *text;
|
struct offsetinfo oi;
|
struct offsetinfo oi;
|
|
|
/* Only happens for usage error. */
|
/* Only happens for usage error. */
|
if (abfd == NULL)
|
if (abfd == NULL)
|
return;
|
return;
|
|
|
oi.sd = sd;
|
oi.sd = sd;
|
oi.offset = offset;
|
oi.offset = offset;
|
|
|
bfd_map_over_sections (abfd, cris_set_section_offset_iterator, &oi);
|
bfd_map_over_sections (abfd, cris_set_section_offset_iterator, &oi);
|
ret = bfd_set_start_address (abfd, bfd_get_start_address (abfd) + offset);
|
ret = bfd_set_start_address (abfd, bfd_get_start_address (abfd) + offset);
|
|
|
STATE_START_ADDR (sd) = bfd_get_start_address (abfd);
|
STATE_START_ADDR (sd) = bfd_get_start_address (abfd);
|
}
|
}
|
|
|
/* BFD section iterator to find the highest and lowest allocated and
|
/* BFD section iterator to find the highest and lowest allocated and
|
non-allocated section addresses (plus one). */
|
non-allocated section addresses (plus one). */
|
|
|
static void
|
static void
|
get_progbounds_iterator (bfd *abfd ATTRIBUTE_UNUSED, asection *s, void *vp)
|
get_progbounds_iterator (bfd *abfd ATTRIBUTE_UNUSED, asection *s, void *vp)
|
{
|
{
|
struct progbounds *pbp = (struct progbounds *) vp;
|
struct progbounds *pbp = (struct progbounds *) vp;
|
|
|
if ((bfd_get_section_flags (abfd, s) & SEC_ALLOC))
|
if ((bfd_get_section_flags (abfd, s) & SEC_ALLOC))
|
{
|
{
|
bfd_size_type sec_size = bfd_get_section_size (s);
|
bfd_size_type sec_size = bfd_get_section_size (s);
|
bfd_size_type sec_start = bfd_get_section_vma (abfd, s);
|
bfd_size_type sec_start = bfd_get_section_vma (abfd, s);
|
bfd_size_type sec_end = sec_start + sec_size;
|
bfd_size_type sec_end = sec_start + sec_size;
|
|
|
if (sec_end > pbp->endmem)
|
if (sec_end > pbp->endmem)
|
pbp->endmem = sec_end;
|
pbp->endmem = sec_end;
|
|
|
if (sec_start < pbp->startmem)
|
if (sec_start < pbp->startmem)
|
pbp->startmem = sec_start;
|
pbp->startmem = sec_start;
|
|
|
if ((bfd_get_section_flags (abfd, s) & SEC_LOAD))
|
if ((bfd_get_section_flags (abfd, s) & SEC_LOAD))
|
{
|
{
|
if (sec_end > pbp->end_loadmem)
|
if (sec_end > pbp->end_loadmem)
|
pbp->end_loadmem = sec_end;
|
pbp->end_loadmem = sec_end;
|
}
|
}
|
else if (sec_start < pbp->start_nonloadmem)
|
else if (sec_start < pbp->start_nonloadmem)
|
pbp->start_nonloadmem = sec_start;
|
pbp->start_nonloadmem = sec_start;
|
}
|
}
|
}
|
}
|
|
|
/* Get the program boundaries. Because not everything is covered by
|
/* Get the program boundaries. Because not everything is covered by
|
sections in ELF, notably the program headers, we use the program
|
sections in ELF, notably the program headers, we use the program
|
headers instead. */
|
headers instead. */
|
|
|
static void
|
static void
|
cris_get_progbounds (struct bfd *abfd, struct progbounds *pbp)
|
cris_get_progbounds (struct bfd *abfd, struct progbounds *pbp)
|
{
|
{
|
Elf_Internal_Phdr *phdr;
|
Elf_Internal_Phdr *phdr;
|
int n_hdrs;
|
int n_hdrs;
|
int i;
|
int i;
|
|
|
pbp->startmem = 0xffffffff;
|
pbp->startmem = 0xffffffff;
|
pbp->endmem = 0;
|
pbp->endmem = 0;
|
pbp->end_loadmem = 0;
|
pbp->end_loadmem = 0;
|
pbp->start_nonloadmem = 0xffffffff;
|
pbp->start_nonloadmem = 0xffffffff;
|
|
|
/* In case we're ever used for something other than ELF, use the
|
/* In case we're ever used for something other than ELF, use the
|
generic method. */
|
generic method. */
|
if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
|
if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
|
{
|
{
|
bfd_map_over_sections (abfd, get_progbounds_iterator, pbp);
|
bfd_map_over_sections (abfd, get_progbounds_iterator, pbp);
|
return;
|
return;
|
}
|
}
|
|
|
phdr = elf_tdata (abfd)->phdr;
|
phdr = elf_tdata (abfd)->phdr;
|
n_hdrs = elf_elfheader (abfd)->e_phnum;
|
n_hdrs = elf_elfheader (abfd)->e_phnum;
|
|
|
/* We're only interested in PT_LOAD; all necessary information
|
/* We're only interested in PT_LOAD; all necessary information
|
should be covered by that. */
|
should be covered by that. */
|
for (i = 0; i < n_hdrs; i++)
|
for (i = 0; i < n_hdrs; i++)
|
{
|
{
|
if (phdr[i].p_type != PT_LOAD)
|
if (phdr[i].p_type != PT_LOAD)
|
continue;
|
continue;
|
|
|
if (phdr[i].p_paddr < pbp->startmem)
|
if (phdr[i].p_paddr < pbp->startmem)
|
pbp->startmem = phdr[i].p_paddr;
|
pbp->startmem = phdr[i].p_paddr;
|
|
|
if (phdr[i].p_paddr + phdr[i].p_memsz > pbp->endmem)
|
if (phdr[i].p_paddr + phdr[i].p_memsz > pbp->endmem)
|
pbp->endmem = phdr[i].p_paddr + phdr[i].p_memsz;
|
pbp->endmem = phdr[i].p_paddr + phdr[i].p_memsz;
|
|
|
if (phdr[i].p_paddr + phdr[i].p_filesz > pbp->end_loadmem)
|
if (phdr[i].p_paddr + phdr[i].p_filesz > pbp->end_loadmem)
|
pbp->end_loadmem = phdr[i].p_paddr + phdr[i].p_filesz;
|
pbp->end_loadmem = phdr[i].p_paddr + phdr[i].p_filesz;
|
|
|
if (phdr[i].p_memsz > phdr[i].p_filesz
|
if (phdr[i].p_memsz > phdr[i].p_filesz
|
&& phdr[i].p_paddr + phdr[i].p_filesz < pbp->start_nonloadmem)
|
&& phdr[i].p_paddr + phdr[i].p_filesz < pbp->start_nonloadmem)
|
pbp->start_nonloadmem = phdr[i].p_paddr + phdr[i].p_filesz;
|
pbp->start_nonloadmem = phdr[i].p_paddr + phdr[i].p_filesz;
|
}
|
}
|
}
|
}
|
|
|
/* Parameter communication by static variables, hmm... Oh well, for
|
/* Parameter communication by static variables, hmm... Oh well, for
|
simplicity. */
|
simplicity. */
|
static bfd_vma exec_load_addr;
|
static bfd_vma exec_load_addr;
|
static bfd_vma interp_load_addr;
|
static bfd_vma interp_load_addr;
|
static bfd_vma interp_start_addr;
|
static bfd_vma interp_start_addr;
|
|
|
/* Supposed to mimic Linux' "NEW_AUX_ENT (AT_PHDR, load_addr + exec->e_phoff)". */
|
/* Supposed to mimic Linux' "NEW_AUX_ENT (AT_PHDR, load_addr + exec->e_phoff)". */
|
|
|
static USI
|
static USI
|
aux_ent_phdr (struct bfd *ebfd)
|
aux_ent_phdr (struct bfd *ebfd)
|
{
|
{
|
return elf_elfheader (ebfd)->e_phoff + exec_load_addr;
|
return elf_elfheader (ebfd)->e_phoff + exec_load_addr;
|
}
|
}
|
|
|
/* We just pass on the header info; we don't have our own idea of the
|
/* We just pass on the header info; we don't have our own idea of the
|
program header entry size. */
|
program header entry size. */
|
|
|
static USI
|
static USI
|
aux_ent_phent (struct bfd *ebfd)
|
aux_ent_phent (struct bfd *ebfd)
|
{
|
{
|
return elf_elfheader (ebfd)->e_phentsize;
|
return elf_elfheader (ebfd)->e_phentsize;
|
}
|
}
|
|
|
/* Like "NEW_AUX_ENT(AT_PHNUM, exec->e_phnum)". */
|
/* Like "NEW_AUX_ENT(AT_PHNUM, exec->e_phnum)". */
|
|
|
static USI
|
static USI
|
aux_ent_phnum (struct bfd *ebfd)
|
aux_ent_phnum (struct bfd *ebfd)
|
{
|
{
|
return elf_elfheader (ebfd)->e_phnum;
|
return elf_elfheader (ebfd)->e_phnum;
|
}
|
}
|
|
|
/* Like "NEW_AUX_ENT(AT_BASE, interp_load_addr)". */
|
/* Like "NEW_AUX_ENT(AT_BASE, interp_load_addr)". */
|
|
|
static USI
|
static USI
|
aux_ent_base (struct bfd *ebfd)
|
aux_ent_base (struct bfd *ebfd)
|
{
|
{
|
return interp_load_addr;
|
return interp_load_addr;
|
}
|
}
|
|
|
/* Like "NEW_AUX_ENT(AT_ENTRY, exec->e_entry)". */
|
/* Like "NEW_AUX_ENT(AT_ENTRY, exec->e_entry)". */
|
|
|
static USI
|
static USI
|
aux_ent_entry (struct bfd *ebfd)
|
aux_ent_entry (struct bfd *ebfd)
|
{
|
{
|
ASSERT (elf_elfheader (ebfd)->e_entry == bfd_get_start_address (ebfd));
|
ASSERT (elf_elfheader (ebfd)->e_entry == bfd_get_start_address (ebfd));
|
return elf_elfheader (ebfd)->e_entry;
|
return elf_elfheader (ebfd)->e_entry;
|
}
|
}
|
|
|
/* Helper for cris_handle_interpreter: like sim_write, but load at
|
/* Helper for cris_handle_interpreter: like sim_write, but load at
|
interp_load_addr offset. */
|
interp_load_addr offset. */
|
|
|
static int
|
static int
|
cris_write_interp (SIM_DESC sd, SIM_ADDR mem, unsigned char *buf, int length)
|
cris_write_interp (SIM_DESC sd, SIM_ADDR mem, unsigned char *buf, int length)
|
{
|
{
|
return sim_write (sd, mem + interp_load_addr, buf, length);
|
return sim_write (sd, mem + interp_load_addr, buf, length);
|
}
|
}
|
|
|
/* Cater to the presence of an interpreter: load it and set
|
/* Cater to the presence of an interpreter: load it and set
|
interp_start_addr. Return FALSE if there was an error, TRUE if
|
interp_start_addr. Return FALSE if there was an error, TRUE if
|
everything went fine, including an interpreter being absent and
|
everything went fine, including an interpreter being absent and
|
the program being in a non-ELF format. */
|
the program being in a non-ELF format. */
|
|
|
static bfd_boolean
|
static bfd_boolean
|
cris_handle_interpreter (SIM_DESC sd, struct bfd *abfd)
|
cris_handle_interpreter (SIM_DESC sd, struct bfd *abfd)
|
{
|
{
|
int i, n_hdrs;
|
int i, n_hdrs;
|
bfd_vma phaddr;
|
bfd_vma phaddr;
|
bfd_byte buf[4];
|
bfd_byte buf[4];
|
char *interp = NULL;
|
char *interp = NULL;
|
struct bfd *ibfd;
|
struct bfd *ibfd;
|
bfd_boolean ok = FALSE;
|
bfd_boolean ok = FALSE;
|
Elf_Internal_Phdr *phdr;
|
Elf_Internal_Phdr *phdr;
|
|
|
if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
|
if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
|
return TRUE;
|
return TRUE;
|
|
|
phdr = elf_tdata (abfd)->phdr;
|
phdr = elf_tdata (abfd)->phdr;
|
n_hdrs = aux_ent_phnum (abfd);
|
n_hdrs = aux_ent_phnum (abfd);
|
|
|
/* Check the program headers for presence of an interpreter. */
|
/* Check the program headers for presence of an interpreter. */
|
for (i = 0; i < n_hdrs; i++)
|
for (i = 0; i < n_hdrs; i++)
|
{
|
{
|
int interplen;
|
int interplen;
|
bfd_size_type interpsiz, interp_filesiz;
|
bfd_size_type interpsiz, interp_filesiz;
|
struct progbounds interp_bounds;
|
struct progbounds interp_bounds;
|
|
|
if (phdr[i].p_type != PT_INTERP)
|
if (phdr[i].p_type != PT_INTERP)
|
continue;
|
continue;
|
|
|
/* Get the name of the interpreter, prepended with the sysroot
|
/* Get the name of the interpreter, prepended with the sysroot
|
(empty if absent). */
|
(empty if absent). */
|
interplen = phdr[i].p_filesz;
|
interplen = phdr[i].p_filesz;
|
interp = xmalloc (interplen + strlen (simulator_sysroot));
|
interp = xmalloc (interplen + strlen (simulator_sysroot));
|
strcpy (interp, simulator_sysroot);
|
strcpy (interp, simulator_sysroot);
|
|
|
/* Read in the name. */
|
/* Read in the name. */
|
if (bfd_seek (abfd, phdr[i].p_offset, SEEK_SET) != 0
|
if (bfd_seek (abfd, phdr[i].p_offset, SEEK_SET) != 0
|
|| (bfd_bread (interp + strlen (simulator_sysroot), interplen, abfd)
|
|| (bfd_bread (interp + strlen (simulator_sysroot), interplen, abfd)
|
!= interplen))
|
!= interplen))
|
goto interpname_failed;
|
goto interpname_failed;
|
|
|
/* Like Linux, require the string to be 0-terminated. */
|
/* Like Linux, require the string to be 0-terminated. */
|
if (interp[interplen + strlen (simulator_sysroot) - 1] != 0)
|
if (interp[interplen + strlen (simulator_sysroot) - 1] != 0)
|
goto interpname_failed;
|
goto interpname_failed;
|
|
|
/* Inspect the interpreter. */
|
/* Inspect the interpreter. */
|
ibfd = bfd_openr (interp, STATE_TARGET (sd));
|
ibfd = bfd_openr (interp, STATE_TARGET (sd));
|
if (ibfd == NULL)
|
if (ibfd == NULL)
|
goto interpname_failed;
|
goto interpname_failed;
|
|
|
/* The interpreter is at least something readable to BFD; make
|
/* The interpreter is at least something readable to BFD; make
|
sure it's an ELF non-archive file. */
|
sure it's an ELF non-archive file. */
|
if (!bfd_check_format (ibfd, bfd_object)
|
if (!bfd_check_format (ibfd, bfd_object)
|
|| bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
|
|| bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
|
goto interp_failed;
|
goto interp_failed;
|
|
|
/* Check the layout of the interpreter. */
|
/* Check the layout of the interpreter. */
|
cris_get_progbounds (ibfd, &interp_bounds);
|
cris_get_progbounds (ibfd, &interp_bounds);
|
|
|
/* Round down to pagesize the start page and up the endpage.
|
/* Round down to pagesize the start page and up the endpage.
|
Don't round the *load and *nonload members. */
|
Don't round the *load and *nonload members. */
|
interp_bounds.startmem &= ~8191;
|
interp_bounds.startmem &= ~8191;
|
interp_bounds.endmem = (interp_bounds.endmem + 8191) & ~8191;
|
interp_bounds.endmem = (interp_bounds.endmem + 8191) & ~8191;
|
|
|
/* Until we need a more dynamic solution, assume we can put the
|
/* Until we need a more dynamic solution, assume we can put the
|
interpreter at this fixed location. NB: this is not what
|
interpreter at this fixed location. NB: this is not what
|
happens for Linux 2008-12-28, but it could and might and
|
happens for Linux 2008-12-28, but it could and might and
|
perhaps should. */
|
perhaps should. */
|
interp_load_addr = 0x40000;
|
interp_load_addr = 0x40000;
|
interpsiz = interp_bounds.endmem - interp_bounds.startmem;
|
interpsiz = interp_bounds.endmem - interp_bounds.startmem;
|
interp_filesiz = interp_bounds.end_loadmem - interp_bounds.startmem;
|
interp_filesiz = interp_bounds.end_loadmem - interp_bounds.startmem;
|
|
|
/* If we have a non-DSO or interpreter starting at the wrong
|
/* If we have a non-DSO or interpreter starting at the wrong
|
address, bail. */
|
address, bail. */
|
if (interp_bounds.startmem != 0
|
if (interp_bounds.startmem != 0
|
|| interpsiz + interp_load_addr >= exec_load_addr)
|
|| interpsiz + interp_load_addr >= exec_load_addr)
|
goto interp_failed;
|
goto interp_failed;
|
|
|
/* We don't have the API to get the address of a simulator
|
/* We don't have the API to get the address of a simulator
|
memory area, so we go via a temporary area. Luckily, the
|
memory area, so we go via a temporary area. Luckily, the
|
interpreter is supposed to be small, less than 0x40000
|
interpreter is supposed to be small, less than 0x40000
|
bytes. */
|
bytes. */
|
sim_do_commandf (sd, "memory region 0x%lx,0x%lx",
|
sim_do_commandf (sd, "memory region 0x%lx,0x%lx",
|
interp_load_addr, interpsiz);
|
interp_load_addr, interpsiz);
|
|
|
/* Now that memory for the interpreter is defined, load it. */
|
/* Now that memory for the interpreter is defined, load it. */
|
if (!cris_load_elf_file (sd, ibfd, cris_write_interp))
|
if (!cris_load_elf_file (sd, ibfd, cris_write_interp))
|
goto interp_failed;
|
goto interp_failed;
|
|
|
/* It's no use setting STATE_START_ADDR, because it gets
|
/* It's no use setting STATE_START_ADDR, because it gets
|
overwritten by a sim_analyze_program call in sim_load. Let's
|
overwritten by a sim_analyze_program call in sim_load. Let's
|
just store it locally. */
|
just store it locally. */
|
interp_start_addr
|
interp_start_addr
|
= (bfd_get_start_address (ibfd)
|
= (bfd_get_start_address (ibfd)
|
- interp_bounds.startmem + interp_load_addr);
|
- interp_bounds.startmem + interp_load_addr);
|
|
|
/* Linux cares only about the first PT_INTERP, so let's ignore
|
/* Linux cares only about the first PT_INTERP, so let's ignore
|
the rest. */
|
the rest. */
|
goto all_done;
|
goto all_done;
|
}
|
}
|
|
|
/* Register R10 should hold 0 at static start (no finifunc), but
|
/* Register R10 should hold 0 at static start (no finifunc), but
|
that's the default, so don't bother. */
|
that's the default, so don't bother. */
|
return TRUE;
|
return TRUE;
|
|
|
all_done:
|
all_done:
|
ok = TRUE;
|
ok = TRUE;
|
|
|
interp_failed:
|
interp_failed:
|
bfd_close (ibfd);
|
bfd_close (ibfd);
|
|
|
interpname_failed:
|
interpname_failed:
|
if (!ok)
|
if (!ok)
|
sim_io_eprintf (sd,
|
sim_io_eprintf (sd,
|
"%s: could not load ELF interpreter `%s' for program `%s'\n",
|
"%s: could not load ELF interpreter `%s' for program `%s'\n",
|
STATE_MY_NAME (sd),
|
STATE_MY_NAME (sd),
|
interp == NULL ? "(what's-its-name)" : interp,
|
interp == NULL ? "(what's-its-name)" : interp,
|
bfd_get_filename (abfd));
|
bfd_get_filename (abfd));
|
free (interp);
|
free (interp);
|
return ok;
|
return ok;
|
}
|
}
|
|
|
/* Create an instance of the simulator. */
|
/* Create an instance of the simulator. */
|
|
|
SIM_DESC
|
SIM_DESC
|
sim_open (SIM_OPEN_KIND kind, host_callback *callback, struct bfd *abfd,
|
sim_open (SIM_OPEN_KIND kind, host_callback *callback, struct bfd *abfd,
|
char **argv)
|
char **argv)
|
{
|
{
|
char c;
|
char c;
|
int i;
|
int i;
|
USI startmem = 0;
|
USI startmem = 0;
|
USI endmem = CRIS_DEFAULT_MEM_SIZE;
|
USI endmem = CRIS_DEFAULT_MEM_SIZE;
|
USI endbrk = endmem;
|
USI endbrk = endmem;
|
USI stack_low = 0;
|
USI stack_low = 0;
|
SIM_DESC sd = sim_state_alloc (kind, callback);
|
SIM_DESC sd = sim_state_alloc (kind, callback);
|
|
|
static const struct auxv_entries_s
|
static const struct auxv_entries_s
|
{
|
{
|
bfd_byte id;
|
bfd_byte id;
|
USI (*efn) (struct bfd *ebfd);
|
USI (*efn) (struct bfd *ebfd);
|
USI val;
|
USI val;
|
} auxv_entries[] =
|
} auxv_entries[] =
|
{
|
{
|
#define AUX_ENT(a, b) {a, NULL, b}
|
#define AUX_ENT(a, b) {a, NULL, b}
|
#define AUX_ENTF(a, f) {a, f, 0}
|
#define AUX_ENTF(a, f) {a, f, 0}
|
AUX_ENT (AT_HWCAP, 0),
|
AUX_ENT (AT_HWCAP, 0),
|
AUX_ENT (AT_PAGESZ, 8192),
|
AUX_ENT (AT_PAGESZ, 8192),
|
AUX_ENT (AT_CLKTCK, 100),
|
AUX_ENT (AT_CLKTCK, 100),
|
AUX_ENTF (AT_PHDR, aux_ent_phdr),
|
AUX_ENTF (AT_PHDR, aux_ent_phdr),
|
AUX_ENTF (AT_PHENT, aux_ent_phent),
|
AUX_ENTF (AT_PHENT, aux_ent_phent),
|
AUX_ENTF (AT_PHNUM, aux_ent_phnum),
|
AUX_ENTF (AT_PHNUM, aux_ent_phnum),
|
AUX_ENTF (AT_BASE, aux_ent_base),
|
AUX_ENTF (AT_BASE, aux_ent_base),
|
AUX_ENT (AT_FLAGS, 0),
|
AUX_ENT (AT_FLAGS, 0),
|
AUX_ENTF (AT_ENTRY, aux_ent_entry),
|
AUX_ENTF (AT_ENTRY, aux_ent_entry),
|
|
|
/* Or is root better? Maybe have it settable? */
|
/* Or is root better? Maybe have it settable? */
|
AUX_ENT (AT_UID, 500),
|
AUX_ENT (AT_UID, 500),
|
AUX_ENT (AT_EUID, 500),
|
AUX_ENT (AT_EUID, 500),
|
AUX_ENT (AT_GID, 500),
|
AUX_ENT (AT_GID, 500),
|
AUX_ENT (AT_EGID, 500),
|
AUX_ENT (AT_EGID, 500),
|
AUX_ENT (AT_SECURE, 0),
|
AUX_ENT (AT_SECURE, 0),
|
AUX_ENT (AT_NULL, 0)
|
AUX_ENT (AT_NULL, 0)
|
};
|
};
|
|
|
/* Can't initialize to "" below. It's either a GCC bug in old
|
/* Can't initialize to "" below. It's either a GCC bug in old
|
releases (up to and including 2.95.3 (.4 in debian) or a bug in the
|
releases (up to and including 2.95.3 (.4 in debian) or a bug in the
|
standard ;-) that the rest of the elements won't be initialized. */
|
standard ;-) that the rest of the elements won't be initialized. */
|
bfd_byte sp_init[4] = {0, 0, 0, 0};
|
bfd_byte sp_init[4] = {0, 0, 0, 0};
|
|
|
/* The cpu data is kept in a separately allocated chunk of memory. */
|
/* The cpu data is kept in a separately allocated chunk of memory. */
|
if (sim_cpu_alloc_all (sd, 1, cgen_cpu_max_extra_bytes ()) != SIM_RC_OK)
|
if (sim_cpu_alloc_all (sd, 1, cgen_cpu_max_extra_bytes ()) != SIM_RC_OK)
|
{
|
{
|
free_state (sd);
|
free_state (sd);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
if (sim_pre_argv_init (sd, argv[0]) != SIM_RC_OK)
|
if (sim_pre_argv_init (sd, argv[0]) != SIM_RC_OK)
|
{
|
{
|
free_state (sd);
|
free_state (sd);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* getopt will print the error message so we just have to exit if this fails.
|
/* getopt will print the error message so we just have to exit if this fails.
|
FIXME: Hmmm... in the case of gdb we need getopt to call
|
FIXME: Hmmm... in the case of gdb we need getopt to call
|
print_filtered. */
|
print_filtered. */
|
if (sim_parse_args (sd, argv) != SIM_RC_OK)
|
if (sim_parse_args (sd, argv) != SIM_RC_OK)
|
{
|
{
|
free_state (sd);
|
free_state (sd);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* If we have a binary program, endianness-setting would not be taken
|
/* If we have a binary program, endianness-setting would not be taken
|
from elsewhere unfortunately, so set it here. At the time of this
|
from elsewhere unfortunately, so set it here. At the time of this
|
writing, it isn't used until sim_config, but that might change so
|
writing, it isn't used until sim_config, but that might change so
|
set it here before memory is defined or touched. */
|
set it here before memory is defined or touched. */
|
current_target_byte_order = LITTLE_ENDIAN;
|
current_target_byte_order = LITTLE_ENDIAN;
|
|
|
/* check for/establish the reference program image */
|
/* check for/establish the reference program image */
|
if (sim_analyze_program (sd,
|
if (sim_analyze_program (sd,
|
(STATE_PROG_ARGV (sd) != NULL
|
(STATE_PROG_ARGV (sd) != NULL
|
? *STATE_PROG_ARGV (sd)
|
? *STATE_PROG_ARGV (sd)
|
: NULL),
|
: NULL),
|
abfd) != SIM_RC_OK)
|
abfd) != SIM_RC_OK)
|
{
|
{
|
/* When there's an error, sim_analyze_program has already output
|
/* When there's an error, sim_analyze_program has already output
|
a message. Let's just clarify it, as "not an object file"
|
a message. Let's just clarify it, as "not an object file"
|
perhaps doesn't ring a bell. */
|
perhaps doesn't ring a bell. */
|
sim_io_eprintf (sd, "(not a CRIS program)\n");
|
sim_io_eprintf (sd, "(not a CRIS program)\n");
|
free_state (sd);
|
free_state (sd);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* We might get called with the caller expecting us to get hold of
|
/* We might get called with the caller expecting us to get hold of
|
the bfd for ourselves, which would happen at the
|
the bfd for ourselves, which would happen at the
|
sim_analyze_program call above. */
|
sim_analyze_program call above. */
|
if (abfd == NULL)
|
if (abfd == NULL)
|
abfd = STATE_PROG_BFD (sd);
|
abfd = STATE_PROG_BFD (sd);
|
|
|
/* Adjust the addresses of the program at this point. Unfortunately
|
/* Adjust the addresses of the program at this point. Unfortunately
|
this does not affect ELF program headers, so we have to handle
|
this does not affect ELF program headers, so we have to handle
|
that separately. */
|
that separately. */
|
cris_offset_sections (sd, cris_program_offset);
|
cris_offset_sections (sd, cris_program_offset);
|
|
|
if (abfd != NULL && bfd_get_arch (abfd) == bfd_arch_unknown)
|
if (abfd != NULL && bfd_get_arch (abfd) == bfd_arch_unknown)
|
{
|
{
|
if (STATE_PROG_ARGV (sd) != NULL)
|
if (STATE_PROG_ARGV (sd) != NULL)
|
sim_io_eprintf (sd, "%s: `%s' is not a CRIS program\n",
|
sim_io_eprintf (sd, "%s: `%s' is not a CRIS program\n",
|
STATE_MY_NAME (sd), *STATE_PROG_ARGV (sd));
|
STATE_MY_NAME (sd), *STATE_PROG_ARGV (sd));
|
else
|
else
|
sim_io_eprintf (sd, "%s: program to be run is not a CRIS program\n",
|
sim_io_eprintf (sd, "%s: program to be run is not a CRIS program\n",
|
STATE_MY_NAME (sd));
|
STATE_MY_NAME (sd));
|
free_state (sd);
|
free_state (sd);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* For CRIS simulator-specific use, we need to find out the bounds of
|
/* For CRIS simulator-specific use, we need to find out the bounds of
|
the program as well, which is not done by sim_analyze_program
|
the program as well, which is not done by sim_analyze_program
|
above. */
|
above. */
|
if (abfd != NULL)
|
if (abfd != NULL)
|
{
|
{
|
struct progbounds pb;
|
struct progbounds pb;
|
|
|
/* The sections should now be accessible using bfd functions. */
|
/* The sections should now be accessible using bfd functions. */
|
cris_get_progbounds (abfd, &pb);
|
cris_get_progbounds (abfd, &pb);
|
|
|
/* We align the area that the program uses to page boundaries. */
|
/* We align the area that the program uses to page boundaries. */
|
startmem = pb.startmem & ~8191;
|
startmem = pb.startmem & ~8191;
|
endbrk = pb.endmem;
|
endbrk = pb.endmem;
|
endmem = (endbrk + 8191) & ~8191;
|
endmem = (endbrk + 8191) & ~8191;
|
}
|
}
|
|
|
/* Find out how much room is needed for the environment and argv, create
|
/* Find out how much room is needed for the environment and argv, create
|
that memory and fill it. Only do this when there's a program
|
that memory and fill it. Only do this when there's a program
|
specified. */
|
specified. */
|
if (abfd != NULL && !cris_bare_iron)
|
if (abfd != NULL && !cris_bare_iron)
|
{
|
{
|
char *name = bfd_get_filename (abfd);
|
char *name = bfd_get_filename (abfd);
|
char **my_environ = GET_ENVIRON ();
|
char **my_environ = GET_ENVIRON ();
|
/* We use these maps to give the same behavior as the old xsim
|
/* We use these maps to give the same behavior as the old xsim
|
simulator. */
|
simulator. */
|
USI envtop = 0x40000000;
|
USI envtop = 0x40000000;
|
USI stacktop = 0x3e000000;
|
USI stacktop = 0x3e000000;
|
USI envstart;
|
USI envstart;
|
int envc;
|
int envc;
|
int len = strlen (name) + 1;
|
int len = strlen (name) + 1;
|
USI epp, epp0;
|
USI epp, epp0;
|
USI stacklen;
|
USI stacklen;
|
int i;
|
int i;
|
char **prog_argv = STATE_PROG_ARGV (sd);
|
char **prog_argv = STATE_PROG_ARGV (sd);
|
int my_argc = 0;
|
int my_argc = 0;
|
/* All CPU:s have the same memory map, apparently. */
|
/* All CPU:s have the same memory map, apparently. */
|
SIM_CPU *cpu = STATE_CPU (sd, 0);
|
SIM_CPU *cpu = STATE_CPU (sd, 0);
|
USI csp;
|
USI csp;
|
bfd_byte buf[4];
|
bfd_byte buf[4];
|
|
|
/* Count in the environment as well. */
|
/* Count in the environment as well. */
|
for (envc = 0; my_environ[envc] != NULL; envc++)
|
for (envc = 0; my_environ[envc] != NULL; envc++)
|
len += strlen (my_environ[envc]) + 1;
|
len += strlen (my_environ[envc]) + 1;
|
|
|
for (i = 0; prog_argv[i] != NULL; my_argc++, i++)
|
for (i = 0; prog_argv[i] != NULL; my_argc++, i++)
|
len += strlen (prog_argv[i]) + 1;
|
len += strlen (prog_argv[i]) + 1;
|
|
|
envstart = (envtop - len) & ~8191;
|
envstart = (envtop - len) & ~8191;
|
|
|
/* Create read-only block for the environment strings. */
|
/* Create read-only block for the environment strings. */
|
sim_core_attach (sd, NULL, 0, access_read, 0,
|
sim_core_attach (sd, NULL, 0, access_read, 0,
|
envstart, (len + 8191) & ~8191,
|
envstart, (len + 8191) & ~8191,
|
0, NULL, NULL);
|
0, NULL, NULL);
|
|
|
/* This shouldn't happen. */
|
/* This shouldn't happen. */
|
if (envstart < stacktop)
|
if (envstart < stacktop)
|
stacktop = envstart - 64 * 8192;
|
stacktop = envstart - 64 * 8192;
|
|
|
csp = stacktop;
|
csp = stacktop;
|
|
|
/* Note that the linux kernel does not correctly compute the storage
|
/* Note that the linux kernel does not correctly compute the storage
|
needs for the static-exe AUX vector. */
|
needs for the static-exe AUX vector. */
|
|
|
csp -= sizeof (auxv_entries) / sizeof (auxv_entries[0]) * 4 * 2;
|
csp -= sizeof (auxv_entries) / sizeof (auxv_entries[0]) * 4 * 2;
|
|
|
csp -= (envc + 1) * 4;
|
csp -= (envc + 1) * 4;
|
csp -= (my_argc + 1) * 4;
|
csp -= (my_argc + 1) * 4;
|
csp -= 4;
|
csp -= 4;
|
|
|
/* Write the target representation of the start-up-value for the
|
/* Write the target representation of the start-up-value for the
|
stack-pointer suitable for register initialization below. */
|
stack-pointer suitable for register initialization below. */
|
bfd_putl32 (csp, sp_init);
|
bfd_putl32 (csp, sp_init);
|
|
|
/* If we make this 1M higher; say 8192*1024, we have to take
|
/* If we make this 1M higher; say 8192*1024, we have to take
|
special precautions for pthreads, because pthreads assumes that
|
special precautions for pthreads, because pthreads assumes that
|
the memory that low isn't mmapped, and that it can mmap it
|
the memory that low isn't mmapped, and that it can mmap it
|
without fallback in case of failure (and we fail ungracefully
|
without fallback in case of failure (and we fail ungracefully
|
long before *that*: the memory isn't accounted for in our mmap
|
long before *that*: the memory isn't accounted for in our mmap
|
list). */
|
list). */
|
stack_low = (csp - (7168*1024)) & ~8191;
|
stack_low = (csp - (7168*1024)) & ~8191;
|
|
|
stacklen = stacktop - stack_low;
|
stacklen = stacktop - stack_low;
|
|
|
/* Tee hee, we have an executable stack. Well, it's necessary to
|
/* Tee hee, we have an executable stack. Well, it's necessary to
|
test GCC trampolines... */
|
test GCC trampolines... */
|
sim_core_attach (sd, NULL, 0, access_read_write_exec, 0,
|
sim_core_attach (sd, NULL, 0, access_read_write_exec, 0,
|
stack_low, stacklen,
|
stack_low, stacklen,
|
0, NULL, NULL);
|
0, NULL, NULL);
|
|
|
epp = epp0 = envstart;
|
epp = epp0 = envstart;
|
|
|
/* Can't use sim_core_write_unaligned_4 without everything
|
/* Can't use sim_core_write_unaligned_4 without everything
|
initialized when tracing, and then these writes would get into
|
initialized when tracing, and then these writes would get into
|
the trace. */
|
the trace. */
|
#define write_dword(addr, data) \
|
#define write_dword(addr, data) \
|
do \
|
do \
|
{ \
|
{ \
|
USI data_ = data; \
|
USI data_ = data; \
|
USI addr_ = addr; \
|
USI addr_ = addr; \
|
bfd_putl32 (data_, buf); \
|
bfd_putl32 (data_, buf); \
|
if (sim_core_write_buffer (sd, cpu, 0, buf, addr_, 4) != 4) \
|
if (sim_core_write_buffer (sd, cpu, 0, buf, addr_, 4) != 4) \
|
goto abandon_chip; \
|
goto abandon_chip; \
|
} \
|
} \
|
while (0)
|
while (0)
|
|
|
write_dword (csp, my_argc);
|
write_dword (csp, my_argc);
|
csp += 4;
|
csp += 4;
|
|
|
for (i = 0; i < my_argc; i++, csp += 4)
|
for (i = 0; i < my_argc; i++, csp += 4)
|
{
|
{
|
size_t strln = strlen (prog_argv[i]) + 1;
|
size_t strln = strlen (prog_argv[i]) + 1;
|
|
|
if (sim_core_write_buffer (sd, cpu, 0, prog_argv[i], epp, strln)
|
if (sim_core_write_buffer (sd, cpu, 0, prog_argv[i], epp, strln)
|
!= strln)
|
!= strln)
|
goto abandon_chip;
|
goto abandon_chip;
|
|
|
write_dword (csp, envstart + epp - epp0);
|
write_dword (csp, envstart + epp - epp0);
|
epp += strln;
|
epp += strln;
|
}
|
}
|
|
|
write_dword (csp, 0);
|
write_dword (csp, 0);
|
csp += 4;
|
csp += 4;
|
|
|
for (i = 0; i < envc; i++, csp += 4)
|
for (i = 0; i < envc; i++, csp += 4)
|
{
|
{
|
unsigned int strln = strlen (my_environ[i]) + 1;
|
unsigned int strln = strlen (my_environ[i]) + 1;
|
|
|
if (sim_core_write_buffer (sd, cpu, 0, my_environ[i], epp, strln)
|
if (sim_core_write_buffer (sd, cpu, 0, my_environ[i], epp, strln)
|
!= strln)
|
!= strln)
|
goto abandon_chip;
|
goto abandon_chip;
|
|
|
write_dword (csp, envstart + epp - epp0);
|
write_dword (csp, envstart + epp - epp0);
|
epp += strln;
|
epp += strln;
|
}
|
}
|
|
|
write_dword (csp, 0);
|
write_dword (csp, 0);
|
csp += 4;
|
csp += 4;
|
|
|
/* The load address of the executable could presumably be
|
/* The load address of the executable could presumably be
|
different than the lowest used memory address, but let's
|
different than the lowest used memory address, but let's
|
stick to simplicity until needed. And
|
stick to simplicity until needed. And
|
cris_handle_interpreter might change startmem and endmem, so
|
cris_handle_interpreter might change startmem and endmem, so
|
let's set it now. */
|
let's set it now. */
|
exec_load_addr = startmem;
|
exec_load_addr = startmem;
|
|
|
if (!cris_handle_interpreter (sd, abfd))
|
if (!cris_handle_interpreter (sd, abfd))
|
goto abandon_chip;
|
goto abandon_chip;
|
|
|
if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
|
if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
|
for (i = 0; i < sizeof (auxv_entries) / sizeof (auxv_entries[0]); i++)
|
for (i = 0; i < sizeof (auxv_entries) / sizeof (auxv_entries[0]); i++)
|
{
|
{
|
write_dword (csp, auxv_entries[i].id);
|
write_dword (csp, auxv_entries[i].id);
|
write_dword (csp + 4,
|
write_dword (csp + 4,
|
auxv_entries[i].efn != NULL
|
auxv_entries[i].efn != NULL
|
? (*auxv_entries[i].efn) (abfd)
|
? (*auxv_entries[i].efn) (abfd)
|
: auxv_entries[i].val);
|
: auxv_entries[i].val);
|
csp += 4 + 4;
|
csp += 4 + 4;
|
}
|
}
|
}
|
}
|
|
|
/* Allocate core managed memory if none specified by user. */
|
/* Allocate core managed memory if none specified by user. */
|
if (sim_core_read_buffer (sd, NULL, read_map, &c, startmem, 1) == 0)
|
if (sim_core_read_buffer (sd, NULL, read_map, &c, startmem, 1) == 0)
|
sim_do_commandf (sd, "memory region 0x%lx,0x%lx", startmem,
|
sim_do_commandf (sd, "memory region 0x%lx,0x%lx", startmem,
|
endmem - startmem);
|
endmem - startmem);
|
|
|
/* Allocate simulator I/O managed memory if none specified by user. */
|
/* Allocate simulator I/O managed memory if none specified by user. */
|
if (cris_have_900000xxif)
|
if (cris_have_900000xxif)
|
{
|
{
|
if (sim_core_read_buffer (sd, NULL, read_map, &c, 0x90000000, 1) == 0)
|
if (sim_core_read_buffer (sd, NULL, read_map, &c, 0x90000000, 1) == 0)
|
sim_core_attach (sd, NULL, 0, access_write, 0, 0x90000000, 0x100,
|
sim_core_attach (sd, NULL, 0, access_write, 0, 0x90000000, 0x100,
|
0, &cris_devices, NULL);
|
0, &cris_devices, NULL);
|
else
|
else
|
{
|
{
|
(*callback->
|
(*callback->
|
printf_filtered) (callback,
|
printf_filtered) (callback,
|
"Seeing --cris-900000xx with memory defined there\n");
|
"Seeing --cris-900000xx with memory defined there\n");
|
goto abandon_chip;
|
goto abandon_chip;
|
}
|
}
|
}
|
}
|
|
|
/* Establish any remaining configuration options. */
|
/* Establish any remaining configuration options. */
|
if (sim_config (sd) != SIM_RC_OK)
|
if (sim_config (sd) != SIM_RC_OK)
|
{
|
{
|
abandon_chip:
|
abandon_chip:
|
free_state (sd);
|
free_state (sd);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
if (sim_post_argv_init (sd) != SIM_RC_OK)
|
if (sim_post_argv_init (sd) != SIM_RC_OK)
|
{
|
{
|
free_state (sd);
|
free_state (sd);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Open a copy of the cpu descriptor table. */
|
/* Open a copy of the cpu descriptor table. */
|
{
|
{
|
CGEN_CPU_DESC cd = cris_cgen_cpu_open_1 (STATE_ARCHITECTURE (sd)->printable_name,
|
CGEN_CPU_DESC cd = cris_cgen_cpu_open_1 (STATE_ARCHITECTURE (sd)->printable_name,
|
CGEN_ENDIAN_LITTLE);
|
CGEN_ENDIAN_LITTLE);
|
for (i = 0; i < MAX_NR_PROCESSORS; ++i)
|
for (i = 0; i < MAX_NR_PROCESSORS; ++i)
|
{
|
{
|
SIM_CPU *cpu = STATE_CPU (sd, i);
|
SIM_CPU *cpu = STATE_CPU (sd, i);
|
CPU_CPU_DESC (cpu) = cd;
|
CPU_CPU_DESC (cpu) = cd;
|
CPU_DISASSEMBLER (cpu) = cris_disassemble_insn;
|
CPU_DISASSEMBLER (cpu) = cris_disassemble_insn;
|
|
|
/* See cris_option_handler for the reason why this is needed. */
|
/* See cris_option_handler for the reason why this is needed. */
|
CPU_CRIS_MISC_PROFILE (cpu)->flags = STATE_TRACE_FLAGS (sd)[0];
|
CPU_CRIS_MISC_PROFILE (cpu)->flags = STATE_TRACE_FLAGS (sd)[0];
|
|
|
/* Set SP to the stack we allocated above. */
|
/* Set SP to the stack we allocated above. */
|
(* CPU_REG_STORE (cpu)) (cpu, H_GR_SP, (char *) sp_init, 4);
|
(* CPU_REG_STORE (cpu)) (cpu, H_GR_SP, (char *) sp_init, 4);
|
|
|
/* Set the simulator environment data. */
|
/* Set the simulator environment data. */
|
cpu->highest_mmapped_page = NULL;
|
cpu->highest_mmapped_page = NULL;
|
cpu->endmem = endmem;
|
cpu->endmem = endmem;
|
cpu->endbrk = endbrk;
|
cpu->endbrk = endbrk;
|
cpu->stack_low = stack_low;
|
cpu->stack_low = stack_low;
|
cpu->syscalls = 0;
|
cpu->syscalls = 0;
|
cpu->m1threads = 0;
|
cpu->m1threads = 0;
|
cpu->threadno = 0;
|
cpu->threadno = 0;
|
cpu->max_threadid = 0;
|
cpu->max_threadid = 0;
|
cpu->thread_data = NULL;
|
cpu->thread_data = NULL;
|
memset (cpu->sighandler, 0, sizeof (cpu->sighandler));
|
memset (cpu->sighandler, 0, sizeof (cpu->sighandler));
|
cpu->make_thread_cpu_data = NULL;
|
cpu->make_thread_cpu_data = NULL;
|
cpu->thread_cpu_data_size = 0;
|
cpu->thread_cpu_data_size = 0;
|
#if WITH_HW
|
#if WITH_HW
|
cpu->deliver_interrupt = NULL;
|
cpu->deliver_interrupt = NULL;
|
#endif
|
#endif
|
}
|
}
|
#if WITH_HW
|
#if WITH_HW
|
/* Always be cycle-accurate and call before/after functions if
|
/* Always be cycle-accurate and call before/after functions if
|
with-hardware. */
|
with-hardware. */
|
sim_profile_set_option (sd, "-model", PROFILE_MODEL_IDX, "on");
|
sim_profile_set_option (sd, "-model", PROFILE_MODEL_IDX, "on");
|
#endif
|
#endif
|
}
|
}
|
|
|
/* Initialize various cgen things not done by common framework.
|
/* Initialize various cgen things not done by common framework.
|
Must be done after cris_cgen_cpu_open. */
|
Must be done after cris_cgen_cpu_open. */
|
cgen_init (sd);
|
cgen_init (sd);
|
|
|
/* Store in a global so things like cris_dump_regs can be invoked
|
/* Store in a global so things like cris_dump_regs can be invoked
|
from the gdb command line. */
|
from the gdb command line. */
|
current_state = sd;
|
current_state = sd;
|
|
|
cris_set_callbacks (callback);
|
cris_set_callbacks (callback);
|
|
|
return sd;
|
return sd;
|
}
|
}
|
|
|
void
|
void
|
sim_close (SIM_DESC sd, int quitting ATTRIBUTE_UNUSED)
|
sim_close (SIM_DESC sd, int quitting ATTRIBUTE_UNUSED)
|
{
|
{
|
cris_cgen_cpu_close (CPU_CPU_DESC (STATE_CPU (sd, 0)));
|
cris_cgen_cpu_close (CPU_CPU_DESC (STATE_CPU (sd, 0)));
|
sim_module_uninstall (sd);
|
sim_module_uninstall (sd);
|
}
|
}
|
|
|
SIM_RC
|
SIM_RC
|
sim_create_inferior (SIM_DESC sd, struct bfd *abfd,
|
sim_create_inferior (SIM_DESC sd, struct bfd *abfd,
|
char **argv ATTRIBUTE_UNUSED,
|
char **argv ATTRIBUTE_UNUSED,
|
char **envp ATTRIBUTE_UNUSED)
|
char **envp ATTRIBUTE_UNUSED)
|
{
|
{
|
SIM_CPU *current_cpu = STATE_CPU (sd, 0);
|
SIM_CPU *current_cpu = STATE_CPU (sd, 0);
|
SIM_ADDR addr;
|
SIM_ADDR addr;
|
|
|
if (sd != NULL)
|
if (sd != NULL)
|
addr = cris_start_address != (SIM_ADDR) -1
|
addr = cris_start_address != (SIM_ADDR) -1
|
? cris_start_address
|
? cris_start_address
|
: (interp_start_addr != 0
|
: (interp_start_addr != 0
|
? interp_start_addr
|
? interp_start_addr
|
: bfd_get_start_address (abfd));
|
: bfd_get_start_address (abfd));
|
else
|
else
|
addr = 0;
|
addr = 0;
|
sim_pc_set (current_cpu, addr);
|
sim_pc_set (current_cpu, addr);
|
|
|
/* Other simulators have #if 0:d code that says
|
/* Other simulators have #if 0:d code that says
|
STATE_ARGV (sd) = sim_copy_argv (argv);
|
STATE_ARGV (sd) = sim_copy_argv (argv);
|
STATE_ENVP (sd) = sim_copy_argv (envp);
|
STATE_ENVP (sd) = sim_copy_argv (envp);
|
Enabling that gives you not-found link-errors for sim_copy_argv.
|
Enabling that gives you not-found link-errors for sim_copy_argv.
|
FIXME: Do archaeology to find out more. */
|
FIXME: Do archaeology to find out more. */
|
|
|
return SIM_RC_OK;
|
return SIM_RC_OK;
|
}
|
}
|
|
|
void
|
void
|
sim_do_command (SIM_DESC sd, char *cmd)
|
sim_do_command (SIM_DESC sd, char *cmd)
|
{
|
{
|
if (sim_args_command (sd, cmd) != SIM_RC_OK)
|
if (sim_args_command (sd, cmd) != SIM_RC_OK)
|
sim_io_eprintf (sd, "Unknown command `%s'\n", cmd);
|
sim_io_eprintf (sd, "Unknown command `%s'\n", cmd);
|
}
|
}
|
|
|
/* Disassemble an instruction. */
|
/* Disassemble an instruction. */
|
|
|
static void
|
static void
|
cris_disassemble_insn (SIM_CPU *cpu,
|
cris_disassemble_insn (SIM_CPU *cpu,
|
const CGEN_INSN *insn ATTRIBUTE_UNUSED,
|
const CGEN_INSN *insn ATTRIBUTE_UNUSED,
|
const ARGBUF *abuf ATTRIBUTE_UNUSED,
|
const ARGBUF *abuf ATTRIBUTE_UNUSED,
|
IADDR pc, char *buf)
|
IADDR pc, char *buf)
|
{
|
{
|
disassembler_ftype pinsn;
|
disassembler_ftype pinsn;
|
struct disassemble_info disasm_info;
|
struct disassemble_info disasm_info;
|
SFILE sfile;
|
SFILE sfile;
|
SIM_DESC sd = CPU_STATE (cpu);
|
SIM_DESC sd = CPU_STATE (cpu);
|
|
|
sfile.buffer = sfile.current = buf;
|
sfile.buffer = sfile.current = buf;
|
INIT_DISASSEMBLE_INFO (disasm_info, (FILE *) &sfile,
|
INIT_DISASSEMBLE_INFO (disasm_info, (FILE *) &sfile,
|
(fprintf_ftype) sim_disasm_sprintf);
|
(fprintf_ftype) sim_disasm_sprintf);
|
disasm_info.endian = BFD_ENDIAN_LITTLE;
|
disasm_info.endian = BFD_ENDIAN_LITTLE;
|
disasm_info.read_memory_func = sim_disasm_read_memory;
|
disasm_info.read_memory_func = sim_disasm_read_memory;
|
disasm_info.memory_error_func = sim_disasm_perror_memory;
|
disasm_info.memory_error_func = sim_disasm_perror_memory;
|
disasm_info.application_data = (PTR) cpu;
|
disasm_info.application_data = (PTR) cpu;
|
pinsn = cris_get_disassembler (STATE_PROG_BFD (sd));
|
pinsn = cris_get_disassembler (STATE_PROG_BFD (sd));
|
(*pinsn) (pc, &disasm_info);
|
(*pinsn) (pc, &disasm_info);
|
}
|
}
|
|
|
