X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=sim%2Fcris%2Fsim-if.c;h=5af802b908d4aa8971076eb087c4046b381737c9;hb=363a6e9f2c3fe1e25f8fa986347948897f189f39;hp=86d19b2f187c0f541ad1615cd1ecb2bc05a29a14;hpb=aad3b3cbc1391fb0091d03b252bd53fbd1d2dd84;p=deliverable%2Fbinutils-gdb.git
diff --git a/sim/cris/sim-if.c b/sim/cris/sim-if.c
index 86d19b2f18..5af802b908 100644
--- a/sim/cris/sim-if.c
+++ b/sim/cris/sim-if.c
@@ -1,33 +1,35 @@
/* Main simulator entry points specific to the CRIS.
- Copyright (C) 2004, 2005, 2006 Free Software Foundation, Inc.
+ Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010
+ Free Software Foundation, Inc.
Contributed by Axis Communications.
This file is part of the GNU simulators.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
-any later version.
+the Free Software Foundation; either version 3 of the License, or
+(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+You should have received a copy of the GNU General Public License
+along with this program. If not, see . */
/* Based on the fr30 file, mixing in bits from the i960 and pruning of
dead code. */
#include "libiberty.h"
#include "bfd.h"
+#include "elf-bfd.h"
#include "sim-main.h"
#ifdef HAVE_STDLIB_H
#include
#endif
+#include
#include "sim-options.h"
#include "dis-asm.h"
@@ -41,32 +43,18 @@ char *missing_environ[] = { "SHELL=/bin/sh", "PATH=/bin:/usr/bin", NULL };
#define GET_ENVIRON() missing_environ
#endif
-/* AUX vector entries. */
-#define TARGET_AT_NULL 0
-#define TARGET_AT_PHDR 3
-#define TARGET_AT_PHENT 4
-#define TARGET_AT_PHNUM 5
-#define TARGET_AT_PAGESZ 6
-#define TARGET_AT_BASE 7
-#define TARGET_AT_FLAGS 8
-#define TARGET_AT_ENTRY 9
-#define TARGET_AT_UID 11
-#define TARGET_AT_EUID 12
-#define TARGET_AT_GID 13
-#define TARGET_AT_EGID 14
-#define TARGET_AT_HWCAP 16
-#define TARGET_AT_CLKTCK 17
-
/* 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
invalid memory accesses program bugs. */
struct progbounds {
USI startmem;
USI endmem;
+ USI end_loadmem;
+ USI start_nonloadmem;
};
static void free_state (SIM_DESC);
-static void get_progbounds (bfd *, asection *, void *);
+static void get_progbounds_iterator (bfd *, asection *, void *);
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
@@ -80,6 +68,19 @@ static char cris_bare_iron = 0;
/* Whether 0x9000000xx have simulator-specific meanings. */
char cris_have_900000xxif = 0;
+/* Used to optionally override the default start address of the
+ simulation. */
+static USI cris_start_address = 0xffffffffu;
+
+/* Used to optionally add offsets to the loaded image and its start
+ address. (Not used for the interpreter of dynamically loaded
+ programs or the DSO:s.) */
+static int cris_program_offset = 0;
+
+/* What to do when we face a more or less unknown syscall. */
+enum cris_unknown_syscall_action_type cris_unknown_syscall_action
+ = CRIS_USYSC_MSG_STOP;
+
/* Records simulator descriptor so utilities like cris_dump_regs can be
called from gdb. */
SIM_DESC current_state;
@@ -89,7 +90,10 @@ typedef enum {
OPTION_CRIS_STATS = OPTION_START,
OPTION_CRIS_TRACE,
OPTION_CRIS_NAKED,
+ OPTION_CRIS_PROGRAM_OFFSET,
+ OPTION_CRIS_STARTADDR,
OPTION_CRIS_900000XXIF,
+ OPTION_CRIS_UNKNOWN_SYSCALL
} CRIS_OPTIONS;
static const OPTION cris_options[] =
@@ -108,6 +112,18 @@ static const OPTION cris_options[] =
{ {"cris-900000xx", no_argument, NULL, OPTION_CRIS_900000XXIF},
'\0', NULL, "Define addresses at 0x900000xx with simulator semantics",
cris_option_handler, NULL },
+ { {"cris-unknown-syscall", required_argument, NULL,
+ OPTION_CRIS_UNKNOWN_SYSCALL},
+ '\0', "stop|enosys|enosys-quiet", "Action at an unknown system call",
+ cris_option_handler, NULL },
+ { {"cris-program-offset", required_argument, NULL,
+ OPTION_CRIS_PROGRAM_OFFSET},
+ '\0', "OFFSET",
+ "Offset image addresses and default start address of a program",
+ cris_option_handler },
+ { {"cris-start-address", required_argument, NULL, OPTION_CRIS_STARTADDR},
+ '\0', "ADDRESS", "Set start address",
+ cris_option_handler },
{ {NULL, no_argument, NULL, 0}, '\0', NULL, NULL, NULL, NULL }
};
@@ -134,6 +150,7 @@ cris_option_handler (SIM_DESC sd, sim_cpu *cpu ATTRIBUTE_UNUSED, int opt,
to the module-specific CPU data when we store things in the
cpu-specific structure. */
char *tracefp = STATE_TRACE_FLAGS (sd);
+ char *chp = arg;
switch ((CRIS_OPTIONS) opt)
{
@@ -152,9 +169,9 @@ cris_option_handler (SIM_DESC sd, sim_cpu *cpu ATTRIBUTE_UNUSED, int opt,
*tracefp = FLAG_CRIS_MISC_PROFILE_ALL;
else
{
- /* We'll actually never get here; the caller handles the
- error case. */
- sim_io_eprintf (sd, "Unknown option `--cris-stats=%s'\n", arg);
+ /* Beware; the framework does not handle the error case;
+ we have to do it ourselves. */
+ sim_io_eprintf (sd, "Unknown option `--cris-cycles=%s'\n", arg);
return SIM_RC_FAIL;
}
break;
@@ -177,6 +194,45 @@ cris_option_handler (SIM_DESC sd, sim_cpu *cpu ATTRIBUTE_UNUSED, int opt,
cris_have_900000xxif = 1;
break;
+ case OPTION_CRIS_STARTADDR:
+ errno = 0;
+ cris_start_address = (USI) strtoul (chp, &chp, 0);
+
+ if (errno != 0 || *chp != 0)
+ {
+ sim_io_eprintf (sd, "Invalid option `--cris-start-address=%s'\n",
+ arg);
+ return SIM_RC_FAIL;
+ }
+ break;
+
+ case OPTION_CRIS_PROGRAM_OFFSET:
+ errno = 0;
+ cris_program_offset = (int) strtol (chp, &chp, 0);
+
+ if (errno != 0 || *chp != 0)
+ {
+ sim_io_eprintf (sd, "Invalid option `--cris-program-offset=%s'\n",
+ arg);
+ return SIM_RC_FAIL;
+ }
+ break;
+
+ case OPTION_CRIS_UNKNOWN_SYSCALL:
+ if (strcmp (arg, "enosys") == 0)
+ cris_unknown_syscall_action = CRIS_USYSC_MSG_ENOSYS;
+ else if (strcmp (arg, "enosys-quiet") == 0)
+ cris_unknown_syscall_action = CRIS_USYSC_QUIET_ENOSYS;
+ else if (strcmp (arg, "stop") == 0)
+ cris_unknown_syscall_action = CRIS_USYSC_MSG_STOP;
+ else
+ {
+ sim_io_eprintf (sd, "Unknown option `--cris-unknown-syscall=%s'\n",
+ arg);
+ return SIM_RC_FAIL;
+ }
+ break;
+
default:
/* We'll actually never get here; the caller handles the error
case. */
@@ -188,6 +244,137 @@ cris_option_handler (SIM_DESC sd, sim_cpu *cpu ATTRIBUTE_UNUSED, int opt,
return sim_profile_set_option (sd, "-model", PROFILE_MODEL_IDX, "on");
}
+/* FIXME: Remove these, globalize those in sim-load.c, move elsewhere. */
+
+static void
+xprintf (host_callback *callback, const char *fmt, ...)
+{
+ va_list ap;
+
+ va_start (ap, fmt);
+
+ (*callback->vprintf_filtered) (callback, fmt, ap);
+
+ va_end (ap);
+}
+
+static void
+eprintf (host_callback *callback, const char *fmt, ...)
+{
+ va_list ap;
+
+ va_start (ap, fmt);
+
+ (*callback->evprintf_filtered) (callback, fmt, ap);
+
+ va_end (ap);
+}
+
+/* An ELF-specific simplified ../common/sim-load.c:sim_load_file,
+ using the program headers, not sections, in order to make sure that
+ the program headers themeselves are also loaded. The caller is
+ responsible for asserting that ABFD is an ELF file. */
+
+static bfd_boolean
+cris_load_elf_file (SIM_DESC sd, struct bfd *abfd, sim_write_fn do_write)
+{
+ Elf_Internal_Phdr *phdr;
+ int n_hdrs;
+ int i;
+ bfd_boolean verbose = STATE_OPEN_KIND (sd) == SIM_OPEN_DEBUG;
+ host_callback *callback = STATE_CALLBACK (sd);
+
+ phdr = elf_tdata (abfd)->phdr;
+ n_hdrs = elf_elfheader (abfd)->e_phnum;
+
+ /* We're only interested in PT_LOAD; all necessary information
+ should be covered by that. */
+ for (i = 0; i < n_hdrs; i++)
+ {
+ bfd_byte *buf;
+ bfd_vma lma = STATE_LOAD_AT_LMA_P (sd)
+ ? phdr[i].p_paddr : phdr[i].p_vaddr;
+
+ if (phdr[i].p_type != PT_LOAD)
+ continue;
+
+ buf = xmalloc (phdr[i].p_filesz);
+
+ if (verbose)
+ xprintf (callback, "Loading segment at 0x%lx, size 0x%lx\n",
+ lma, phdr[i].p_filesz);
+
+ if (bfd_seek (abfd, phdr[i].p_offset, SEEK_SET) != 0
+ || (bfd_bread (buf, phdr[i].p_filesz, abfd) != phdr[i].p_filesz))
+ {
+ eprintf (callback,
+ "%s: could not read segment at 0x%lx, size 0x%lx\n",
+ STATE_MY_NAME (sd), lma, phdr[i].p_filesz);
+ free (buf);
+ return FALSE;
+ }
+
+ if (do_write (sd, lma, buf, phdr[i].p_filesz) != phdr[i].p_filesz)
+ {
+ eprintf (callback,
+ "%s: could not load segment at 0x%lx, size 0x%lx\n",
+ STATE_MY_NAME (sd), lma, phdr[i].p_filesz);
+ free (buf);
+ return FALSE;
+ }
+
+ free (buf);
+ }
+
+ return TRUE;
+}
+
+/* Helper for sim_load (needed just for ELF files): like sim_write,
+ but offset load at cris_program_offset offset. */
+
+static int
+cris_program_offset_write (SIM_DESC sd, SIM_ADDR mem, unsigned char *buf,
+ int length)
+{
+ return sim_write (sd, mem + cris_program_offset, buf, length);
+}
+
+/* Replacement for ../common/sim-hload.c:sim_load, so we can treat ELF
+ files differently. */
+
+SIM_RC
+sim_load (SIM_DESC sd, char *prog_name, struct bfd *prog_bfd,
+ int from_tty ATTRIBUTE_UNUSED)
+{
+ bfd *result_bfd;
+
+ if (bfd_get_flavour (prog_bfd) != bfd_target_elf_flavour)
+ {
+ SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
+ if (sim_analyze_program (sd, prog_name, prog_bfd) != SIM_RC_OK)
+ return SIM_RC_FAIL;
+ SIM_ASSERT (STATE_PROG_BFD (sd) != NULL);
+
+ result_bfd = sim_load_file (sd, STATE_MY_NAME (sd),
+ STATE_CALLBACK (sd),
+ prog_name,
+ STATE_PROG_BFD (sd),
+ STATE_OPEN_KIND (sd) == SIM_OPEN_DEBUG,
+ STATE_LOAD_AT_LMA_P (sd),
+ sim_write);
+ if (result_bfd == NULL)
+ {
+ bfd_close (STATE_PROG_BFD (sd));
+ STATE_PROG_BFD (sd) = NULL;
+ return SIM_RC_FAIL;
+ }
+ return SIM_RC_OK;
+ }
+
+ return cris_load_elf_file (sd, prog_bfd, cris_program_offset_write)
+ ? SIM_RC_OK : SIM_RC_FAIL;
+}
+
/* Cover function of sim_state_free to free the cpu buffers as well. */
static void
@@ -199,12 +386,65 @@ free_state (SIM_DESC sd)
sim_state_free (sd);
}
-/* BFD section iterator to find the highest allocated section address
- (plus one). If we could, we should use the program header table
- instead, but we can't get to that using bfd. */
+/* Helper struct for cris_set_section_offset_iterator. */
-void
-get_progbounds (bfd *abfd ATTRIBUTE_UNUSED, asection *s, void *vp)
+struct offsetinfo
+{
+ SIM_DESC sd;
+ int offset;
+};
+
+/* BFD section iterator to offset the LMA and VMA. */
+
+static void
+cris_set_section_offset_iterator (bfd *abfd, asection *s, void *vp)
+{
+ struct offsetinfo *p = (struct offsetinfo *) vp;
+ SIM_DESC sd = p->sd;
+ int offset = p->offset;
+
+ if ((bfd_get_section_flags (abfd, s) & SEC_ALLOC))
+ {
+ bfd_vma vma = bfd_get_section_vma (abfd, s);
+
+ bfd_set_section_vma (abfd, s, vma + offset);
+ }
+
+ /* This seems clumsy and inaccurate, but let's stick to doing it the
+ same way as sim_analyze_program for consistency. */
+ if (strcmp (bfd_get_section_name (abfd, s), ".text") == 0)
+ STATE_TEXT_START (sd) = bfd_get_section_vma (abfd, s);
+}
+
+/* Adjust the start-address, LMA and VMA of a SD. Must be called
+ after sim_analyze_program. */
+
+static void
+cris_offset_sections (SIM_DESC sd, int offset)
+{
+ bfd_boolean ret;
+ struct bfd *abfd = STATE_PROG_BFD (sd);
+ asection *text;
+ struct offsetinfo oi;
+
+ /* Only happens for usage error. */
+ if (abfd == NULL)
+ return;
+
+ oi.sd = sd;
+ oi.offset = offset;
+
+ bfd_map_over_sections (abfd, cris_set_section_offset_iterator, &oi);
+ ret = bfd_set_start_address (abfd, bfd_get_start_address (abfd) + offset);
+
+ STATE_START_ADDR (sd) = bfd_get_start_address (abfd);
+}
+
+/* BFD section iterator to find the highest and lowest allocated and
+ non-allocated section addresses (plus one). */
+
+static void
+get_progbounds_iterator (bfd *abfd ATTRIBUTE_UNUSED, asection *s, void *vp)
{
struct progbounds *pbp = (struct progbounds *) vp;
@@ -219,9 +459,248 @@ get_progbounds (bfd *abfd ATTRIBUTE_UNUSED, asection *s, void *vp)
if (sec_start < pbp->startmem)
pbp->startmem = sec_start;
+
+ if ((bfd_get_section_flags (abfd, s) & SEC_LOAD))
+ {
+ if (sec_end > pbp->end_loadmem)
+ pbp->end_loadmem = sec_end;
+ }
+ else if (sec_start < pbp->start_nonloadmem)
+ pbp->start_nonloadmem = sec_start;
}
}
+/* Get the program boundaries. Because not everything is covered by
+ sections in ELF, notably the program headers, we use the program
+ headers instead. */
+
+static void
+cris_get_progbounds (struct bfd *abfd, struct progbounds *pbp)
+{
+ Elf_Internal_Phdr *phdr;
+ int n_hdrs;
+ int i;
+
+ pbp->startmem = 0xffffffff;
+ pbp->endmem = 0;
+ pbp->end_loadmem = 0;
+ pbp->start_nonloadmem = 0xffffffff;
+
+ /* In case we're ever used for something other than ELF, use the
+ generic method. */
+ if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
+ {
+ bfd_map_over_sections (abfd, get_progbounds_iterator, pbp);
+ return;
+ }
+
+ phdr = elf_tdata (abfd)->phdr;
+ n_hdrs = elf_elfheader (abfd)->e_phnum;
+
+ /* We're only interested in PT_LOAD; all necessary information
+ should be covered by that. */
+ for (i = 0; i < n_hdrs; i++)
+ {
+ if (phdr[i].p_type != PT_LOAD)
+ continue;
+
+ if (phdr[i].p_paddr < pbp->startmem)
+ pbp->startmem = phdr[i].p_paddr;
+
+ if (phdr[i].p_paddr + phdr[i].p_memsz > pbp->endmem)
+ pbp->endmem = phdr[i].p_paddr + phdr[i].p_memsz;
+
+ if (phdr[i].p_paddr + phdr[i].p_filesz > pbp->end_loadmem)
+ pbp->end_loadmem = phdr[i].p_paddr + phdr[i].p_filesz;
+
+ if (phdr[i].p_memsz > phdr[i].p_filesz
+ && phdr[i].p_paddr + phdr[i].p_filesz < pbp->start_nonloadmem)
+ pbp->start_nonloadmem = phdr[i].p_paddr + phdr[i].p_filesz;
+ }
+}
+
+/* Parameter communication by static variables, hmm... Oh well, for
+ simplicity. */
+static bfd_vma exec_load_addr;
+static bfd_vma interp_load_addr;
+static bfd_vma interp_start_addr;
+
+/* Supposed to mimic Linux' "NEW_AUX_ENT (AT_PHDR, load_addr + exec->e_phoff)". */
+
+static USI
+aux_ent_phdr (struct bfd *ebfd)
+{
+ 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
+ program header entry size. */
+
+static USI
+aux_ent_phent (struct bfd *ebfd)
+{
+ return elf_elfheader (ebfd)->e_phentsize;
+}
+
+/* Like "NEW_AUX_ENT(AT_PHNUM, exec->e_phnum)". */
+
+static USI
+aux_ent_phnum (struct bfd *ebfd)
+{
+ return elf_elfheader (ebfd)->e_phnum;
+}
+
+/* Like "NEW_AUX_ENT(AT_BASE, interp_load_addr)". */
+
+static USI
+aux_ent_base (struct bfd *ebfd)
+{
+ return interp_load_addr;
+}
+
+/* Like "NEW_AUX_ENT(AT_ENTRY, exec->e_entry)". */
+
+static USI
+aux_ent_entry (struct bfd *ebfd)
+{
+ ASSERT (elf_elfheader (ebfd)->e_entry == bfd_get_start_address (ebfd));
+ return elf_elfheader (ebfd)->e_entry;
+}
+
+/* Helper for cris_handle_interpreter: like sim_write, but load at
+ interp_load_addr offset. */
+
+static int
+cris_write_interp (SIM_DESC sd, SIM_ADDR mem, unsigned char *buf, int length)
+{
+ return sim_write (sd, mem + interp_load_addr, buf, length);
+}
+
+/* Cater to the presence of an interpreter: load it and set
+ interp_start_addr. Return FALSE if there was an error, TRUE if
+ everything went fine, including an interpreter being absent and
+ the program being in a non-ELF format. */
+
+static bfd_boolean
+cris_handle_interpreter (SIM_DESC sd, struct bfd *abfd)
+{
+ int i, n_hdrs;
+ bfd_vma phaddr;
+ bfd_byte buf[4];
+ char *interp = NULL;
+ struct bfd *ibfd;
+ bfd_boolean ok = FALSE;
+ Elf_Internal_Phdr *phdr;
+
+ if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
+ return TRUE;
+
+ phdr = elf_tdata (abfd)->phdr;
+ n_hdrs = aux_ent_phnum (abfd);
+
+ /* Check the program headers for presence of an interpreter. */
+ for (i = 0; i < n_hdrs; i++)
+ {
+ int interplen;
+ bfd_size_type interpsiz, interp_filesiz;
+ struct progbounds interp_bounds;
+
+ if (phdr[i].p_type != PT_INTERP)
+ continue;
+
+ /* Get the name of the interpreter, prepended with the sysroot
+ (empty if absent). */
+ interplen = phdr[i].p_filesz;
+ interp = xmalloc (interplen + strlen (simulator_sysroot));
+ strcpy (interp, simulator_sysroot);
+
+ /* Read in the name. */
+ if (bfd_seek (abfd, phdr[i].p_offset, SEEK_SET) != 0
+ || (bfd_bread (interp + strlen (simulator_sysroot), interplen, abfd)
+ != interplen))
+ goto interpname_failed;
+
+ /* Like Linux, require the string to be 0-terminated. */
+ if (interp[interplen + strlen (simulator_sysroot) - 1] != 0)
+ goto interpname_failed;
+
+ /* Inspect the interpreter. */
+ ibfd = bfd_openr (interp, STATE_TARGET (sd));
+ if (ibfd == NULL)
+ goto interpname_failed;
+
+ /* The interpreter is at least something readable to BFD; make
+ sure it's an ELF non-archive file. */
+ if (!bfd_check_format (ibfd, bfd_object)
+ || bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
+ goto interp_failed;
+
+ /* Check the layout of the interpreter. */
+ cris_get_progbounds (ibfd, &interp_bounds);
+
+ /* Round down to pagesize the start page and up the endpage.
+ Don't round the *load and *nonload members. */
+ interp_bounds.startmem &= ~8191;
+ interp_bounds.endmem = (interp_bounds.endmem + 8191) & ~8191;
+
+ /* Until we need a more dynamic solution, assume we can put the
+ interpreter at this fixed location. NB: this is not what
+ happens for Linux 2008-12-28, but it could and might and
+ perhaps should. */
+ interp_load_addr = 0x40000;
+ interpsiz = interp_bounds.endmem - interp_bounds.startmem;
+ interp_filesiz = interp_bounds.end_loadmem - interp_bounds.startmem;
+
+ /* If we have a non-DSO or interpreter starting at the wrong
+ address, bail. */
+ if (interp_bounds.startmem != 0
+ || interpsiz + interp_load_addr >= exec_load_addr)
+ goto interp_failed;
+
+ /* We don't have the API to get the address of a simulator
+ memory area, so we go via a temporary area. Luckily, the
+ interpreter is supposed to be small, less than 0x40000
+ bytes. */
+ sim_do_commandf (sd, "memory region 0x%lx,0x%lx",
+ interp_load_addr, interpsiz);
+
+ /* Now that memory for the interpreter is defined, load it. */
+ if (!cris_load_elf_file (sd, ibfd, cris_write_interp))
+ goto interp_failed;
+
+ /* It's no use setting STATE_START_ADDR, because it gets
+ overwritten by a sim_analyze_program call in sim_load. Let's
+ just store it locally. */
+ interp_start_addr
+ = (bfd_get_start_address (ibfd)
+ - interp_bounds.startmem + interp_load_addr);
+
+ /* Linux cares only about the first PT_INTERP, so let's ignore
+ the rest. */
+ goto all_done;
+ }
+
+ /* Register R10 should hold 0 at static start (no finifunc), but
+ that's the default, so don't bother. */
+ return TRUE;
+
+ all_done:
+ ok = TRUE;
+
+ interp_failed:
+ bfd_close (ibfd);
+
+ interpname_failed:
+ if (!ok)
+ sim_io_eprintf (sd,
+ "%s: could not load ELF interpreter `%s' for program `%s'\n",
+ STATE_MY_NAME (sd),
+ interp == NULL ? "(what's-its-name)" : interp,
+ bfd_get_filename (abfd));
+ free (interp);
+ return ok;
+}
+
/* Create an instance of the simulator. */
SIM_DESC
@@ -236,6 +715,34 @@ sim_open (SIM_OPEN_KIND kind, host_callback *callback, struct bfd *abfd,
USI stack_low = 0;
SIM_DESC sd = sim_state_alloc (kind, callback);
+ static const struct auxv_entries_s
+ {
+ bfd_byte id;
+ USI (*efn) (struct bfd *ebfd);
+ USI val;
+ } auxv_entries[] =
+ {
+#define AUX_ENT(a, b) {a, NULL, b}
+#define AUX_ENTF(a, f) {a, f, 0}
+ AUX_ENT (AT_HWCAP, 0),
+ AUX_ENT (AT_PAGESZ, 8192),
+ AUX_ENT (AT_CLKTCK, 100),
+ AUX_ENTF (AT_PHDR, aux_ent_phdr),
+ AUX_ENTF (AT_PHENT, aux_ent_phent),
+ AUX_ENTF (AT_PHNUM, aux_ent_phnum),
+ AUX_ENTF (AT_BASE, aux_ent_base),
+ AUX_ENT (AT_FLAGS, 0),
+ AUX_ENTF (AT_ENTRY, aux_ent_entry),
+
+ /* Or is root better? Maybe have it settable? */
+ AUX_ENT (AT_UID, 500),
+ AUX_ENT (AT_EUID, 500),
+ AUX_ENT (AT_GID, 500),
+ AUX_ENT (AT_EGID, 500),
+ AUX_ENT (AT_SECURE, 0),
+ AUX_ENT (AT_NULL, 0)
+ };
+
/* 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
standard ;-) that the rest of the elements won't be initialized. */
@@ -276,6 +783,33 @@ sim_open (SIM_OPEN_KIND kind, host_callback *callback, struct bfd *abfd,
: NULL),
abfd) != SIM_RC_OK)
{
+ /* When there's an error, sim_analyze_program has already output
+ a message. Let's just clarify it, as "not an object file"
+ perhaps doesn't ring a bell. */
+ sim_io_eprintf (sd, "(not a CRIS program)\n");
+ free_state (sd);
+ return 0;
+ }
+
+ /* We might get called with the caller expecting us to get hold of
+ the bfd for ourselves, which would happen at the
+ sim_analyze_program call above. */
+ if (abfd == NULL)
+ abfd = STATE_PROG_BFD (sd);
+
+ /* Adjust the addresses of the program at this point. Unfortunately
+ this does not affect ELF program headers, so we have to handle
+ that separately. */
+ cris_offset_sections (sd, cris_program_offset);
+
+ if (abfd != NULL && bfd_get_arch (abfd) == bfd_arch_unknown)
+ {
+ if (STATE_PROG_ARGV (sd) != NULL)
+ sim_io_eprintf (sd, "%s: `%s' is not a CRIS program\n",
+ STATE_MY_NAME (sd), *STATE_PROG_ARGV (sd));
+ else
+ sim_io_eprintf (sd, "%s: program to be run is not a CRIS program\n",
+ STATE_MY_NAME (sd));
free_state (sd);
return 0;
}
@@ -283,14 +817,12 @@ sim_open (SIM_OPEN_KIND kind, host_callback *callback, struct bfd *abfd,
/* 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
above. */
- if (STATE_PROG_BFD (sd))
+ if (abfd != NULL)
{
struct progbounds pb;
/* The sections should now be accessible using bfd functions. */
- pb.startmem = 0x7fffffff;
- pb.endmem = 0;
- bfd_map_over_sections (STATE_PROG_BFD (sd), get_progbounds, &pb);
+ cris_get_progbounds (abfd, &pb);
/* We align the area that the program uses to page boundaries. */
startmem = pb.startmem & ~8191;
@@ -301,9 +833,9 @@ sim_open (SIM_OPEN_KIND kind, host_callback *callback, struct bfd *abfd,
/* 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
specified. */
- if (STATE_PROG_BFD (sd) && !cris_bare_iron)
+ if (abfd != NULL && !cris_bare_iron)
{
- char *name = bfd_get_filename (STATE_PROG_BFD (sd));
+ char *name = bfd_get_filename (abfd);
char **my_environ = GET_ENVIRON ();
/* We use these maps to give the same behavior as the old xsim
simulator. */
@@ -344,7 +876,8 @@ sim_open (SIM_OPEN_KIND kind, host_callback *callback, struct bfd *abfd,
/* Note that the linux kernel does not correctly compute the storage
needs for the static-exe AUX vector. */
- csp -= 4 * 4 * 2;
+
+ csp -= sizeof (auxv_entries) / sizeof (auxv_entries[0]) * 4 * 2;
csp -= (envc + 1) * 4;
csp -= (my_argc + 1) * 4;
@@ -419,28 +952,26 @@ sim_open (SIM_OPEN_KIND kind, host_callback *callback, struct bfd *abfd,
write_dword (csp, 0);
csp += 4;
-#define NEW_AUX_ENT(nr, id, val) \
- do \
- { \
- write_dword (csp + (nr) * 4 * 2, (id)); \
- write_dword (csp + (nr) * 4 * 2 + 4, (val)); \
- } \
- while (0)
-
- /* Note that there are some extra AUX entries for a dynlinked
- program loaded image. */
-
- /* AUX entries always present. */
- NEW_AUX_ENT (0, TARGET_AT_HWCAP, 0);
- NEW_AUX_ENT (1, TARGET_AT_PAGESZ, 8192);
- NEW_AUX_ENT (2, TARGET_AT_CLKTCK, 100);
+ /* The load address of the executable could presumably be
+ different than the lowest used memory address, but let's
+ stick to simplicity until needed. And
+ cris_handle_interpreter might change startmem and endmem, so
+ let's set it now. */
+ exec_load_addr = startmem;
- csp += 4 * 2 * 3;
- NEW_AUX_ENT (0, TARGET_AT_NULL, 0);
-#undef NEW_AUX_ENT
+ if (!cris_handle_interpreter (sd, abfd))
+ goto abandon_chip;
- /* Register R10 should hold 0 at static start (no initfunc), but
- that's the default, so don't bother. */
+ if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
+ for (i = 0; i < sizeof (auxv_entries) / sizeof (auxv_entries[0]); i++)
+ {
+ write_dword (csp, auxv_entries[i].id);
+ write_dword (csp + 4,
+ auxv_entries[i].efn != NULL
+ ? (*auxv_entries[i].efn) (abfd)
+ : auxv_entries[i].val);
+ csp += 4 + 4;
+ }
}
/* Allocate core managed memory if none specified by user. */
@@ -545,8 +1076,12 @@ sim_create_inferior (SIM_DESC sd, struct bfd *abfd,
SIM_CPU *current_cpu = STATE_CPU (sd, 0);
SIM_ADDR addr;
- if (abfd != NULL)
- addr = bfd_get_start_address (abfd);
+ if (sd != NULL)
+ addr = cris_start_address != (SIM_ADDR) -1
+ ? cris_start_address
+ : (interp_start_addr != 0
+ ? interp_start_addr
+ : bfd_get_start_address (abfd));
else
addr = 0;
sim_pc_set (current_cpu, addr);
@@ -583,14 +1118,8 @@ cris_disassemble_insn (SIM_CPU *cpu,
sfile.buffer = sfile.current = buf;
INIT_DISASSEMBLE_INFO (disasm_info, (FILE *) &sfile,
(fprintf_ftype) sim_disasm_sprintf);
- disasm_info.endian =
- (bfd_big_endian (STATE_PROG_BFD (sd)) ? BFD_ENDIAN_BIG
- : bfd_little_endian (STATE_PROG_BFD (sd)) ? BFD_ENDIAN_LITTLE
- : BFD_ENDIAN_UNKNOWN);
- /* We live with the cast until the prototype is fixed, or else we get a
- warning because the functions differ in the signedness of one parameter. */
- disasm_info.read_memory_func =
- sim_disasm_read_memory;
+ disasm_info.endian = BFD_ENDIAN_LITTLE;
+ disasm_info.read_memory_func = sim_disasm_read_memory;
disasm_info.memory_error_func = sim_disasm_perror_memory;
disasm_info.application_data = (PTR) cpu;
pinsn = cris_get_disassembler (STATE_PROG_BFD (sd));