int
main (int argc, char **argv)
{
char *name;
char **prog_argv = NULL;
struct bfd *prog_bfd;
enum sim_stop reason;
int sigrc = 0;
int single_step = 0;
RETSIGTYPE (*prev_sigint) ();
myname = argv[0] + strlen (argv[0]);
while (myname > argv[0] && myname[-1] != '/')
--myname;
/* INTERNAL: When MYNAME is `step', single step the simulator
instead of allowing it to run free. The sole purpose of this
HACK is to allow the sim_resume interface's step argument to be
tested without having to build/run gdb. */
if (strlen (myname) > 4 && strcmp (myname - 4, "step") == 0)
{
single_step = 1;
}
/* Create an instance of the simulator. */
default_callback.init (&default_callback);
sd = sim_open (SIM_OPEN_STANDALONE, &default_callback, NULL, argv);
if (sd == 0)
exit (1);
if (STATE_MAGIC (sd) != SIM_MAGIC_NUMBER)
{
fprintf (stderr, "Internal error - bad magic number in simulator struct\n");
abort ();
}
/* We can't set the endianness in the callback structure until
sim_config is called, which happens in sim_open. */
default_callback.target_endian
= (CURRENT_TARGET_BYTE_ORDER == BIG_ENDIAN
? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
/* Was there a program to run? */
prog_argv = STATE_PROG_ARGV (sd);
prog_bfd = STATE_PROG_BFD (sd);
if (prog_argv == NULL || *prog_argv == NULL)
usage ();
name = *prog_argv;
/* For simulators that don't open prog during sim_open() */
if (prog_bfd == NULL)
{
prog_bfd = bfd_openr (name, 0);
if (prog_bfd == NULL)
{
fprintf (stderr, "%s: can't open \"%s\": %s\n",
myname, name, bfd_errmsg (bfd_get_error ()));
exit (1);
}
if (!bfd_check_format (prog_bfd, bfd_object))
{
fprintf (stderr, "%s: \"%s\" is not an object file: %s\n",
myname, name, bfd_errmsg (bfd_get_error ()));
exit (1);
}
}
if (STATE_VERBOSE_P (sd))
printf ("%s %s\n", myname, name);
/* Load the program into the simulator. */
if (sim_load (sd, name, prog_bfd, 0) == SIM_RC_FAIL)
exit (1);
/* Prepare the program for execution. */
#ifdef HAVE_ENVIRON
sim_create_inferior (sd, prog_bfd, prog_argv, environ);
#else
sim_create_inferior (sd, prog_bfd, prog_argv, NULL);
#endif
/* To accommodate relative file paths, chdir to sysroot now. We
mustn't do this until BFD has opened the program, else we wouldn't
find the executable if it has a relative file path. */
if (simulator_sysroot[0] != '\0' && chdir (simulator_sysroot) < 0)
{
fprintf (stderr, "%s: can't change directory to \"%s\"\n",
myname, simulator_sysroot);
exit (1);
}
/* Run/Step the program. */
if (single_step)
{
do
{
prev_sigint = signal (SIGINT, cntrl_c);
sim_resume (sd, 1/*step*/, 0);
signal (SIGINT, prev_sigint);
sim_stop_reason (sd, &reason, &sigrc);
if ((reason == sim_stopped) &&
(sigrc == sim_signal_to_host (sd, SIM_SIGINT)))
break; /* exit on control-C */
}
/* remain on breakpoint or signals in oe mode*/
while (((reason == sim_signalled) &&
(sigrc == sim_signal_to_host (sd, SIM_SIGTRAP))) ||
((reason == sim_stopped) &&
(STATE_ENVIRONMENT (sd) == OPERATING_ENVIRONMENT)));
}
else
{
do
{
#if defined (HAVE_SIGACTION) && defined (SA_RESTART)
struct sigaction sa, osa;
sa.sa_handler = cntrl_c;
sigemptyset (&sa.sa_mask);
sa.sa_flags = 0;
sigaction (SIGINT, &sa, &osa);
prev_sigint = osa.sa_handler;
#else
prev_sigint = signal (SIGINT, cntrl_c);
#endif
sim_resume (sd, 0, sigrc);
signal (SIGINT, prev_sigint);
sim_stop_reason (sd, &reason, &sigrc);
if ((reason == sim_stopped) &&
(sigrc == sim_signal_to_host (sd, SIM_SIGINT)))
break; /* exit on control-C */
/* remain on signals in oe mode */
} while ((reason == sim_stopped) &&
(STATE_ENVIRONMENT (sd) == OPERATING_ENVIRONMENT));
}
/* Print any stats the simulator collected. */
if (STATE_VERBOSE_P (sd))
sim_info (sd, 0);
/* Shutdown the simulator. */
sim_close (sd, 0);
/* If reason is sim_exited, then sigrc holds the exit code which we want
to return. If reason is sim_stopped or sim_signalled, then sigrc holds
the signal that the simulator received; we want to return that to
indicate failure. */
/* Why did we stop? */
switch (reason)
{
case sim_signalled:
case sim_stopped:
if (sigrc != 0)
fprintf (stderr, "program stopped with signal %d.\n", sigrc);
break;
case sim_exited:
break;
default:
fprintf (stderr, "program in undefined state (%d:%d)\n", reason, sigrc);
break;
}
return sigrc;
}
static void
bfin_user_init (SIM_DESC sd, SIM_CPU *cpu, struct bfd *abfd,
const char * const *argv, const char * const *env)
{
/* XXX: Missing host -> target endian ... */
/* Linux starts the user app with the stack:
argc
argv[0] -- pointers to the actual strings
argv[1..N]
NULL
env[0]
env[1..N]
NULL
auxvt[0].type -- ELF Auxiliary Vector Table
auxvt[0].value
auxvt[1..N]
AT_NULL
0
argv[0..N][0..M] -- actual argv/env strings
env[0..N][0..M]
FDPIC loadmaps -- for FDPIC apps
So set things up the same way. */
int i, argc, envc;
bu32 argv_flat, env_flat;
bu32 sp, sp_flat;
/* start, at_phdr, at_phnum, at_base, at_entry, pt_dynamic */
bu32 elf_addrs[6];
bu32 auxvt;
bu32 exec_loadmap, ldso_loadmap;
char *ldso_path;
unsigned char null[4] = { 0, 0, 0, 0 };
host_callback *cb = STATE_CALLBACK (sd);
elf_addrs[0] = elf_addrs[4] = bfd_get_start_address (abfd);
elf_addrs[1] = elf_addrs[2] = elf_addrs[3] = elf_addrs[5] = 0;
/* Keep the load addresses consistent between runs. Also make sure we make
space for the fixed code region (part of the Blackfin Linux ABI). */
fdpic_load_offset = 0x1000;
/* First try to load this as an FDPIC executable. */
sp = SPREG;
if (!bfin_fdpic_load (sd, cpu, STATE_PROG_BFD (sd), &sp, elf_addrs, &ldso_path))
goto skip_fdpic_init;
exec_loadmap = sp;
/* If that worked, then load the fixed code region. We only do this for
FDPIC ELFs atm because they are PIEs and let us relocate them without
manual fixups. FLAT files however require location processing which
we do not do ourselves, and they link with a VMA of 0. */
sim_write (sd, 0x400, bfin_linux_fixed_code, sizeof (bfin_linux_fixed_code));
/* If the FDPIC needs an interpreter, then load it up too. */
if (ldso_path)
{
const char *ldso_full_path = concat (simulator_sysroot, ldso_path, NULL);
struct bfd *ldso_bfd;
ldso_bfd = bfd_openr (ldso_full_path, STATE_TARGET (sd));
if (!ldso_bfd)
{
sim_io_eprintf (sd, "bfin-sim: bfd open failed: %s\n", ldso_full_path);
goto static_fdpic;
}
if (!bfd_check_format (ldso_bfd, bfd_object))
sim_io_eprintf (sd, "bfin-sim: bfd format not valid: %s\n", ldso_full_path);
bfd_set_arch_info (ldso_bfd, STATE_ARCHITECTURE (sd));
if (!bfin_fdpic_load (sd, cpu, ldso_bfd, &sp, elf_addrs, &ldso_path))
sim_io_eprintf (sd, "bfin-sim: FDPIC ldso failed to load: %s\n", ldso_full_path);
if (ldso_path)
sim_io_eprintf (sd, "bfin-sim: FDPIC ldso (%s) needs an interpreter (%s) !?\n",
ldso_full_path, ldso_path);
ldso_loadmap = sp;
}
else
static_fdpic:
ldso_loadmap = 0;
/* Finally setup the registers required by the FDPIC ABI. */
SET_DREG (7, 0); /* Zero out FINI funcptr -- ldso will set this up. */
SET_PREG (0, exec_loadmap); /* Exec loadmap addr. */
SET_PREG (1, ldso_loadmap); /* Interp loadmap addr. */
SET_PREG (2, elf_addrs[5]); /* PT_DYNAMIC map addr. */
auxvt = 1;
SET_SPREG (sp);
skip_fdpic_init:
sim_pc_set (cpu, elf_addrs[0]);
/* Figure out how much storage the argv/env strings need. */
argc = count_argc (argv);
if (argc == -1)
argc = 0;
argv_flat = argc; /* NUL bytes */
for (i = 0; i < argc; ++i)
argv_flat += strlen (argv[i]);
if (!env)
env = simple_env;
envc = count_argc (env);
env_flat = envc; /* NUL bytes */
for (i = 0; i < envc; ++i)
env_flat += strlen (env[i]);
/* Push the Auxiliary Vector Table between argv/env and actual strings. */
sp_flat = sp = ALIGN (SPREG - argv_flat - env_flat - 4, 4);
if (auxvt)
{
# define AT_PUSH(at, val) \
auxvt_size += 8; \
sp -= 4; \
auxvt = (val); \
sim_write (sd, sp, (void *)&auxvt, 4); \
sp -= 4; \
auxvt = (at); \
sim_write (sd, sp, (void *)&auxvt, 4)
unsigned int egid = getegid (), gid = getgid ();
unsigned int euid = geteuid (), uid = getuid ();
bu32 auxvt_size = 0;
AT_PUSH (AT_NULL, 0);
AT_PUSH (AT_SECURE, egid != gid || euid != uid);
AT_PUSH (AT_EGID, egid);
AT_PUSH (AT_GID, gid);
AT_PUSH (AT_EUID, euid);
AT_PUSH (AT_UID, uid);
AT_PUSH (AT_ENTRY, elf_addrs[4]);
AT_PUSH (AT_FLAGS, 0);
AT_PUSH (AT_BASE, elf_addrs[3]);
AT_PUSH (AT_PHNUM, elf_addrs[2]);
AT_PUSH (AT_PHENT, sizeof (Elf32_External_Phdr));
AT_PUSH (AT_PHDR, elf_addrs[1]);
AT_PUSH (AT_CLKTCK, 100); /* XXX: This ever not 100 ? */
AT_PUSH (AT_PAGESZ, 4096);
AT_PUSH (AT_HWCAP, 0);
#undef AT_PUSH
}
SET_SPREG (sp);
/* Push the argc/argv/env after the auxvt. */
sp -= ((1 + argc + 1 + envc + 1) * 4);
SET_SPREG (sp);
/* First push the argc value. */
sim_write (sd, sp, (void *)&argc, 4);
sp += 4;
/* Then the actual argv strings so we know where to point argv[]. */
for (i = 0; i < argc; ++i)
{
unsigned len = strlen (argv[i]) + 1;
sim_write (sd, sp_flat, (void *)argv[i], len);
sim_write (sd, sp, (void *)&sp_flat, 4);
sp_flat += len;
sp += 4;
}
sim_write (sd, sp, null, 4);
sp += 4;
/* Then the actual env strings so we know where to point env[]. */
for (i = 0; i < envc; ++i)
{
unsigned len = strlen (env[i]) + 1;
sim_write (sd, sp_flat, (void *)env[i], len);
sim_write (sd, sp, (void *)&sp_flat, 4);
sp_flat += len;
sp += 4;
}
/* Set some callbacks. */
cb->syscall_map = cb_linux_syscall_map;
cb->errno_map = cb_linux_errno_map;
cb->open_map = cb_linux_open_map;
cb->signal_map = cb_linux_signal_map;
cb->stat_map = stat_map_32 = cb_linux_stat_map_32;
stat_map_64 = cb_linux_stat_map_64;
}
/* Handle TRA and TIRA insns. */
void
frv_itrap (SIM_CPU *current_cpu, PCADDR pc, USI base, SI offset)
{
SIM_DESC sd = CPU_STATE (current_cpu);
host_callback *cb = STATE_CALLBACK (sd);
USI num = ((base + offset) & 0x7f) + 0x80;
#ifdef SIM_HAVE_BREAKPOINTS
/* Check for breakpoints "owned" by the simulator first, regardless
of --environment. */
if (num == TRAP_BREAKPOINT)
{
/* First try sim-break.c. If it's a breakpoint the simulator "owns"
it doesn't return. Otherwise it returns and let's us try. */
sim_handle_breakpoint (sd, current_cpu, pc);
/* Fall through. */
}
#endif
if (STATE_ENVIRONMENT (sd) == OPERATING_ENVIRONMENT)
{
frv_queue_software_interrupt (current_cpu, num);
return;
}
switch (num)
{
case TRAP_SYSCALL :
{
CB_SYSCALL s;
CB_SYSCALL_INIT (&s);
s.func = GET_H_GR (7);
s.arg1 = GET_H_GR (8);
s.arg2 = GET_H_GR (9);
s.arg3 = GET_H_GR (10);
if (s.func == TARGET_SYS_exit)
{
sim_engine_halt (sd, current_cpu, NULL, pc, sim_exited, s.arg1);
}
s.p1 = (PTR) sd;
s.p2 = (PTR) current_cpu;
s.read_mem = syscall_read_mem;
s.write_mem = syscall_write_mem;
cb_syscall (cb, &s);
SET_H_GR (8, s.result);
SET_H_GR (9, s.result2);
SET_H_GR (10, s.errcode);
break;
}
case TRAP_BREAKPOINT:
sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped, SIM_SIGTRAP);
break;
/* Add support for dumping registers, either at fixed traps, or all
unknown traps if configured with --enable-sim-trapdump. */
default:
#if !TRAPDUMP
frv_queue_software_interrupt (current_cpu, num);
return;
#endif
#ifdef TRAP_REGDUMP1
case TRAP_REGDUMP1:
#endif
#ifdef TRAP_REGDUMP2
case TRAP_REGDUMP2:
#endif
#if TRAPDUMP || (defined (TRAP_REGDUMP1)) || (defined (TRAP_REGDUMP2))
{
char buf[256];
int i, j;
buf[0] = 0;
if (STATE_TEXT_SECTION (sd)
&& pc >= STATE_TEXT_START (sd)
&& pc < STATE_TEXT_END (sd))
{
const char *pc_filename = (const char *)0;
const char *pc_function = (const char *)0;
unsigned int pc_linenum = 0;
if (bfd_find_nearest_line (STATE_PROG_BFD (sd),
STATE_TEXT_SECTION (sd),
(struct bfd_symbol **) 0,
pc - STATE_TEXT_START (sd),
&pc_filename, &pc_function, &pc_linenum)
&& (pc_function || pc_filename))
{
char *p = buf+2;
buf[0] = ' ';
buf[1] = '(';
if (pc_function)
{
strcpy (p, pc_function);
p += strlen (p);
}
else
{
char *q = (char *) strrchr (pc_filename, '/');
strcpy (p, (q) ? q+1 : pc_filename);
p += strlen (p);
}
if (pc_linenum)
{
sprintf (p, " line %d", pc_linenum);
p += strlen (p);
}
p[0] = ')';
p[1] = '\0';
if ((p+1) - buf > sizeof (buf))
abort ();
}
}
sim_io_printf (sd,
"\nRegister dump, pc = 0x%.8x%s, base = %u, offset = %d\n",
(unsigned)pc, buf, (unsigned)base, (int)offset);
for (i = 0; i < 64; i += 8)
{
long g0 = (long)GET_H_GR (i);
long g1 = (long)GET_H_GR (i+1);
long g2 = (long)GET_H_GR (i+2);
long g3 = (long)GET_H_GR (i+3);
long g4 = (long)GET_H_GR (i+4);
long g5 = (long)GET_H_GR (i+5);
long g6 = (long)GET_H_GR (i+6);
long g7 = (long)GET_H_GR (i+7);
if ((g0 | g1 | g2 | g3 | g4 | g5 | g6 | g7) != 0)
sim_io_printf (sd,
"\tgr%02d - gr%02d: 0x%.8lx 0x%.8lx 0x%.8lx 0x%.8lx 0x%.8lx 0x%.8lx 0x%.8lx 0x%.8lx\n",
i, i+7, g0, g1, g2, g3, g4, g5, g6, g7);
}
for (i = 0; i < 64; i += 8)
{
long f0 = (long)GET_H_FR (i);
long f1 = (long)GET_H_FR (i+1);
long f2 = (long)GET_H_FR (i+2);
long f3 = (long)GET_H_FR (i+3);
long f4 = (long)GET_H_FR (i+4);
long f5 = (long)GET_H_FR (i+5);
long f6 = (long)GET_H_FR (i+6);
long f7 = (long)GET_H_FR (i+7);
if ((f0 | f1 | f2 | f3 | f4 | f5 | f6 | f7) != 0)
sim_io_printf (sd,
"\tfr%02d - fr%02d: 0x%.8lx 0x%.8lx 0x%.8lx 0x%.8lx 0x%.8lx 0x%.8lx 0x%.8lx 0x%.8lx\n",
i, i+7, f0, f1, f2, f3, f4, f5, f6, f7);
}
sim_io_printf (sd,
"\tlr/lcr/cc/ccc: 0x%.8lx 0x%.8lx 0x%.8lx 0x%.8lx\n",
(long)GET_H_SPR (272),
(long)GET_H_SPR (273),
(long)GET_H_SPR (256),
(long)GET_H_SPR (263));
}
break;
#endif
}
}
static bool
bfin_fdpic_load (SIM_DESC sd, SIM_CPU *cpu, struct bfd *abfd, bu32 *sp,
bu32 *elf_addrs, char **ldso_path)
{
bool ret;
int i;
Elf_Internal_Ehdr *iehdr;
Elf32_External_Ehdr ehdr;
Elf_Internal_Phdr *phdrs;
unsigned char *data;
long phdr_size;
int phdrc;
bu32 nsegs;
bu32 max_load_addr;
unsigned char null[4] = { 0, 0, 0, 0 };
ret = false;
*ldso_path = NULL;
/* See if this an FDPIC ELF. */
phdrs = NULL;
if (!abfd)
goto skip_fdpic_init;
if (bfd_seek (abfd, 0, SEEK_SET) != 0)
goto skip_fdpic_init;
if (bfd_bread (&ehdr, sizeof (ehdr), abfd) != sizeof (ehdr))
goto skip_fdpic_init;
iehdr = elf_elfheader (abfd);
if (!(iehdr->e_flags & EF_BFIN_FDPIC))
goto skip_fdpic_init;
if (STATE_OPEN_KIND (sd) == SIM_OPEN_DEBUG)
sim_io_printf (sd, "Loading FDPIC ELF %s\n Load base: %#x\n ELF entry: %#x\n",
bfd_get_filename (abfd), fdpic_load_offset, elf_addrs[0]);
/* Grab the Program Headers to set up the loadsegs on the stack. */
phdr_size = bfd_get_elf_phdr_upper_bound (abfd);
if (phdr_size == -1)
goto skip_fdpic_init;
phdrs = xmalloc (phdr_size);
phdrc = bfd_get_elf_phdrs (abfd, phdrs);
if (phdrc == -1)
goto skip_fdpic_init;
/* Push the Ehdr onto the stack. */
*sp -= sizeof (ehdr);
elf_addrs[3] = *sp;
sim_write (sd, *sp, (void *)&ehdr, sizeof (ehdr));
if (STATE_OPEN_KIND (sd) == SIM_OPEN_DEBUG)
sim_io_printf (sd, " Elf_Ehdr: %#x\n", *sp);
/* Since we're relocating things ourselves, we need to relocate
the start address as well. */
elf_addrs[0] = bfd_get_start_address (abfd) + fdpic_load_offset;
/* And the Exec's Phdrs onto the stack. */
if (STATE_PROG_BFD (sd) == abfd)
{
elf_addrs[4] = elf_addrs[0];
phdr_size = iehdr->e_phentsize * iehdr->e_phnum;
if (bfd_seek (abfd, iehdr->e_phoff, SEEK_SET) != 0)
goto skip_fdpic_init;
data = xmalloc (phdr_size);
if (bfd_bread (data, phdr_size, abfd) != phdr_size)
goto skip_fdpic_init;
*sp -= phdr_size;
elf_addrs[1] = *sp;
elf_addrs[2] = phdrc;
sim_write (sd, *sp, data, phdr_size);
free (data);
if (STATE_OPEN_KIND (sd) == SIM_OPEN_DEBUG)
sim_io_printf (sd, " Elf_Phdrs: %#x\n", *sp);
}
/* Now push all the loadsegs. */
nsegs = 0;
max_load_addr = 0;
for (i = phdrc; i >= 0; --i)
if (phdrs[i].p_type == PT_LOAD)
{
Elf_Internal_Phdr *p = &phdrs[i];
bu32 paddr, vaddr, memsz, filesz;
paddr = p->p_paddr + fdpic_load_offset;
vaddr = p->p_vaddr;
memsz = p->p_memsz;
filesz = p->p_filesz;
if (STATE_OPEN_KIND (sd) == SIM_OPEN_DEBUG)
sim_io_printf (sd, " PHDR %i: vma %#x lma %#x filesz %#x memsz %#x\n",
i, vaddr, paddr, filesz, memsz);
data = xmalloc (memsz);
if (memsz != filesz)
memset (data + filesz, 0, memsz - filesz);
if (bfd_seek (abfd, p->p_offset, SEEK_SET) == 0
&& bfd_bread (data, filesz, abfd) == filesz)
sim_write (sd, paddr, data, memsz);
free (data);
max_load_addr = MAX (paddr + memsz, max_load_addr);
*sp -= 12;
sim_write (sd, *sp+0, (void *)&paddr, 4); /* loadseg.addr */
sim_write (sd, *sp+4, (void *)&vaddr, 4); /* loadseg.p_vaddr */
sim_write (sd, *sp+8, (void *)&memsz, 4); /* loadseg.p_memsz */
++nsegs;
}
else if (phdrs[i].p_type == PT_DYNAMIC)
{
elf_addrs[5] = phdrs[i].p_paddr + fdpic_load_offset;
if (STATE_OPEN_KIND (sd) == SIM_OPEN_DEBUG)
sim_io_printf (sd, " PT_DYNAMIC: %#x\n", elf_addrs[5]);
}
else if (phdrs[i].p_type == PT_INTERP)
{
uint32_t off = phdrs[i].p_offset;
uint32_t len = phdrs[i].p_filesz;
*ldso_path = xmalloc (len);
if (bfd_seek (abfd, off, SEEK_SET) != 0
|| bfd_bread (*ldso_path, len, abfd) != len)
{
free (*ldso_path);
*ldso_path = NULL;
}
else if (STATE_OPEN_KIND (sd) == SIM_OPEN_DEBUG)
sim_io_printf (sd, " PT_INTERP: %s\n", *ldso_path);
}
/* Update the load offset with a few extra pages. */
fdpic_load_offset = ALIGN (MAX (max_load_addr, fdpic_load_offset), 0x10000);
fdpic_load_offset += 0x10000;
/* Push the summary loadmap info onto the stack last. */
*sp -= 4;
sim_write (sd, *sp+0, null, 2); /* loadmap.version */
sim_write (sd, *sp+2, (void *)&nsegs, 2); /* loadmap.nsegs */
ret = true;
skip_fdpic_init:
free (phdrs);
return ret;
}
SIM_RC
sim_config (SIM_DESC sd)
{
enum bfd_endian prefered_target_byte_order;
SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
/* extract all relevant information */
if (STATE_PROG_BFD (sd) == NULL
/* If we have a binary input file (presumably with specified
"--architecture"), it'll have no endianness. */
|| (!bfd_little_endian (STATE_PROG_BFD (sd))
&& !bfd_big_endian (STATE_PROG_BFD (sd))))
prefered_target_byte_order = BFD_ENDIAN_UNKNOWN;
else
prefered_target_byte_order = (bfd_little_endian (STATE_PROG_BFD (sd))
? BFD_ENDIAN_LITTLE
: BFD_ENDIAN_BIG);
/* set the target byte order */
#if (WITH_TREE_PROPERTIES)
if (current_target_byte_order == BFD_ENDIAN_UNKNOWN)
current_target_byte_order
= (tree_find_boolean_property (root, "/options/little-endian?")
? BFD_ENDIAN_LITTLE
: BFD_ENDIAN_BIG);
#endif
if (current_target_byte_order == BFD_ENDIAN_UNKNOWN
&& prefered_target_byte_order != BFD_ENDIAN_UNKNOWN)
current_target_byte_order = prefered_target_byte_order;
if (current_target_byte_order == BFD_ENDIAN_UNKNOWN)
current_target_byte_order = WITH_TARGET_BYTE_ORDER;
if (current_target_byte_order == BFD_ENDIAN_UNKNOWN)
current_target_byte_order = WITH_DEFAULT_TARGET_BYTE_ORDER;
/* verify the target byte order */
if (CURRENT_TARGET_BYTE_ORDER == BFD_ENDIAN_UNKNOWN)
{
sim_io_eprintf (sd, "Target byte order unspecified\n");
return SIM_RC_FAIL;
}
if (CURRENT_TARGET_BYTE_ORDER != current_target_byte_order)
sim_io_eprintf (sd, "Target (%s) and configured (%s) byte order in conflict\n",
config_byte_order_to_a (current_target_byte_order),
config_byte_order_to_a (CURRENT_TARGET_BYTE_ORDER));
if (prefered_target_byte_order != BFD_ENDIAN_UNKNOWN
&& CURRENT_TARGET_BYTE_ORDER != prefered_target_byte_order)
sim_io_eprintf (sd, "Target (%s) and specified (%s) byte order in conflict\n",
config_byte_order_to_a (CURRENT_TARGET_BYTE_ORDER),
config_byte_order_to_a (prefered_target_byte_order));
/* set the stdio */
if (current_stdio == 0)
current_stdio = WITH_STDIO;
if (current_stdio == 0)
current_stdio = DO_USE_STDIO;
/* verify the stdio */
if (CURRENT_STDIO == 0)
{
sim_io_eprintf (sd, "Target standard IO unspecified\n");
return SIM_RC_FAIL;
}
if (CURRENT_STDIO != current_stdio)
{
sim_io_eprintf (sd, "Target (%s) and configured (%s) standard IO in conflict\n",
config_stdio_to_a (CURRENT_STDIO),
config_stdio_to_a (current_stdio));
return SIM_RC_FAIL;
}
/* check the value of MSB */
if (WITH_TARGET_WORD_MSB != 0
&& WITH_TARGET_WORD_MSB != (WITH_TARGET_WORD_BITSIZE - 1))
{
sim_io_eprintf (sd, "Target bitsize (%d) contradicts target most significant bit (%d)\n",
WITH_TARGET_WORD_BITSIZE, WITH_TARGET_WORD_MSB);
return SIM_RC_FAIL;
}
/* set the environment */
#if (WITH_TREE_PROPERTIES)
if (STATE_ENVIRONMENT (sd) == ALL_ENVIRONMENT)
{
const char *env =
tree_find_string_property (root, "/openprom/options/env");
STATE_ENVIRONMENT (sd) = ((strcmp (env, "user") == 0
|| strcmp (env, "uea") == 0)
? USER_ENVIRONMENT
: (strcmp (env, "virtual") == 0
|| strcmp (env, "vea") == 0)
? VIRTUAL_ENVIRONMENT
: (strcmp (env, "operating") == 0
|| strcmp (env, "oea") == 0)
? OPERATING_ENVIRONMENT
: ALL_ENVIRONMENT);
}
#endif
if (STATE_ENVIRONMENT (sd) == ALL_ENVIRONMENT)
STATE_ENVIRONMENT (sd) = (WITH_ENVIRONMENT != ALL_ENVIRONMENT ?
WITH_ENVIRONMENT : USER_ENVIRONMENT);
/* set the alignment */
#if (WITH_TREE_PROPERTIES)
if (current_alignment == 0)
current_alignment =
(tree_find_boolean_property (root, "/openprom/options/strict-alignment?")
? STRICT_ALIGNMENT
: NONSTRICT_ALIGNMENT);
#endif
if (current_alignment == 0)
current_alignment = WITH_ALIGNMENT;
if (current_alignment == 0)
current_alignment = WITH_DEFAULT_ALIGNMENT;
/* verify the alignment */
if (CURRENT_ALIGNMENT == 0)
{
sim_io_eprintf (sd, "Target alignment unspecified\n");
return SIM_RC_FAIL;
}
if (CURRENT_ALIGNMENT != current_alignment)
{
sim_io_eprintf (sd, "Target (%s) and configured (%s) alignment in conflict\n",
config_alignment_to_a (CURRENT_ALIGNMENT),
config_alignment_to_a (current_alignment));
return SIM_RC_FAIL;
}
#if defined (WITH_FLOATING_POINT)
/* set the floating point */
if (current_floating_point == 0)
current_floating_point = WITH_FLOATING_POINT;
/* verify the floating point */
if (CURRENT_FLOATING_POINT == 0)
{
sim_io_eprintf (sd, "Target floating-point unspecified\n");
return SIM_RC_FAIL;
}
if (CURRENT_FLOATING_POINT != current_floating_point)
{
sim_io_eprintf (sd, "Target (%s) and configured (%s) floating-point in conflict\n",
config_alignment_to_a (CURRENT_FLOATING_POINT),
config_alignment_to_a (current_floating_point));
return SIM_RC_FAIL;
}
#endif
return SIM_RC_OK;
}