1 /* Main simulator entry points specific to the CRIS.
2 Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009
3 Free Software Foundation, Inc.
4 Contributed by Axis Communications.
6 This file is part of the GNU simulators.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 /* Based on the fr30 file, mixing in bits from the i960 and pruning of
24 #include "libiberty.h"
32 #include "sim-options.h"
35 /* Apparently the autoconf bits are missing (though HAVE_ENVIRON is used
36 in other dirs; also lacking there). Patch around it for major systems. */
37 #if defined (HAVE_ENVIRON) || defined (__GLIBC__)
38 extern char **environ
;
39 #define GET_ENVIRON() environ
41 char *missing_environ
[] = { "SHELL=/bin/sh", "PATH=/bin:/usr/bin", NULL
};
42 #define GET_ENVIRON() missing_environ
45 /* Used with get_progbounds to find out how much memory is needed for the
46 program. We don't want to allocate more, since that could mask
47 invalid memory accesses program bugs. */
55 static void free_state (SIM_DESC
);
56 static void get_progbounds_iterator (bfd
*, asection
*, void *);
57 static SIM_RC
cris_option_handler (SIM_DESC
, sim_cpu
*, int, char *, int);
59 /* Since we don't build the cgen-opcode table, we use the old
61 static CGEN_DISASSEMBLER cris_disassemble_insn
;
63 /* By default, we set up stack and environment variables like the Linux
65 static char cris_bare_iron
= 0;
67 /* Whether 0x9000000xx have simulator-specific meanings. */
68 char cris_have_900000xxif
= 0;
70 /* What to do when we face a more or less unknown syscall. */
71 enum cris_unknown_syscall_action_type cris_unknown_syscall_action
72 = CRIS_USYSC_MSG_STOP
;
74 /* Records simulator descriptor so utilities like cris_dump_regs can be
76 SIM_DESC current_state
;
78 /* CRIS-specific options. */
80 OPTION_CRIS_STATS
= OPTION_START
,
83 OPTION_CRIS_900000XXIF
,
84 OPTION_CRIS_UNKNOWN_SYSCALL
87 static const OPTION cris_options
[] =
89 { {"cris-cycles", required_argument
, NULL
, OPTION_CRIS_STATS
},
90 '\0', "basic|unaligned|schedulable|all",
91 "Dump execution statistics",
92 cris_option_handler
, NULL
},
93 { {"cris-trace", required_argument
, NULL
, OPTION_CRIS_TRACE
},
95 "Emit trace information while running",
96 cris_option_handler
, NULL
},
97 { {"cris-naked", no_argument
, NULL
, OPTION_CRIS_NAKED
},
98 '\0', NULL
, "Don't set up stack and environment",
99 cris_option_handler
, NULL
},
100 { {"cris-900000xx", no_argument
, NULL
, OPTION_CRIS_900000XXIF
},
101 '\0', NULL
, "Define addresses at 0x900000xx with simulator semantics",
102 cris_option_handler
, NULL
},
103 { {"cris-unknown-syscall", required_argument
, NULL
,
104 OPTION_CRIS_UNKNOWN_SYSCALL
},
105 '\0', "stop|enosys|enosys-quiet", "Action at an unknown system call",
106 cris_option_handler
, NULL
},
107 { {NULL
, no_argument
, NULL
, 0}, '\0', NULL
, NULL
, NULL
, NULL
}
110 /* Add the CRIS-specific option list to the simulator. */
113 cris_option_install (SIM_DESC sd
)
115 SIM_ASSERT (STATE_MAGIC (sd
) == SIM_MAGIC_NUMBER
);
116 if (sim_add_option_table (sd
, NULL
, cris_options
) != SIM_RC_OK
)
121 /* Handle CRIS-specific options. */
124 cris_option_handler (SIM_DESC sd
, sim_cpu
*cpu ATTRIBUTE_UNUSED
, int opt
,
125 char *arg
, int is_command ATTRIBUTE_UNUSED
)
127 /* The options are CRIS-specific, but cpu-specific option-handling is
128 broken; required to being with "--cpu0-". We store the flags in an
129 unused field in the global state structure and move the flags over
130 to the module-specific CPU data when we store things in the
131 cpu-specific structure. */
132 char *tracefp
= STATE_TRACE_FLAGS (sd
);
134 switch ((CRIS_OPTIONS
) opt
)
136 case OPTION_CRIS_STATS
:
137 if (strcmp (arg
, "basic") == 0)
138 *tracefp
= FLAG_CRIS_MISC_PROFILE_SIMPLE
;
139 else if (strcmp (arg
, "unaligned") == 0)
141 = (FLAG_CRIS_MISC_PROFILE_UNALIGNED
142 | FLAG_CRIS_MISC_PROFILE_SIMPLE
);
143 else if (strcmp (arg
, "schedulable") == 0)
145 = (FLAG_CRIS_MISC_PROFILE_SCHEDULABLE
146 | FLAG_CRIS_MISC_PROFILE_SIMPLE
);
147 else if (strcmp (arg
, "all") == 0)
148 *tracefp
= FLAG_CRIS_MISC_PROFILE_ALL
;
151 /* Beware; the framework does not handle the error case;
152 we have to do it ourselves. */
153 sim_io_eprintf (sd
, "Unknown option `--cris-cycles=%s'\n", arg
);
158 case OPTION_CRIS_TRACE
:
159 if (strcmp (arg
, "basic") == 0)
160 *tracefp
|= FLAG_CRIS_MISC_PROFILE_XSIM_TRACE
;
163 sim_io_eprintf (sd
, "Unknown option `--cris-trace=%s'\n", arg
);
168 case OPTION_CRIS_NAKED
:
172 case OPTION_CRIS_900000XXIF
:
173 cris_have_900000xxif
= 1;
176 case OPTION_CRIS_UNKNOWN_SYSCALL
:
177 if (strcmp (arg
, "enosys") == 0)
178 cris_unknown_syscall_action
= CRIS_USYSC_MSG_ENOSYS
;
179 else if (strcmp (arg
, "enosys-quiet") == 0)
180 cris_unknown_syscall_action
= CRIS_USYSC_QUIET_ENOSYS
;
181 else if (strcmp (arg
, "stop") == 0)
182 cris_unknown_syscall_action
= CRIS_USYSC_MSG_STOP
;
185 sim_io_eprintf (sd
, "Unknown option `--cris-unknown-syscall=%s'\n",
192 /* We'll actually never get here; the caller handles the error
194 sim_io_eprintf (sd
, "Unknown option `%s'\n", arg
);
198 /* Imply --profile-model=on. */
199 return sim_profile_set_option (sd
, "-model", PROFILE_MODEL_IDX
, "on");
202 /* FIXME: Remove these, globalize those in sim-load.c, move elsewhere. */
205 xprintf (host_callback
*callback
, const char *fmt
, ...)
211 (*callback
->vprintf_filtered
) (callback
, fmt
, ap
);
217 eprintf (host_callback
*callback
, const char *fmt
, ...)
223 (*callback
->evprintf_filtered
) (callback
, fmt
, ap
);
228 /* An ELF-specific simplified ../common/sim-load.c:sim_load_file,
229 using the program headers, not sections, in order to make sure that
230 the program headers themeselves are also loaded. The caller is
231 responsible for asserting that ABFD is an ELF file. */
234 cris_load_elf_file (SIM_DESC sd
, struct bfd
*abfd
, sim_write_fn do_write
)
236 Elf_Internal_Phdr
*phdr
;
239 bfd_boolean verbose
= STATE_OPEN_KIND (sd
) == SIM_OPEN_DEBUG
;
240 host_callback
*callback
= STATE_CALLBACK (sd
);
242 phdr
= elf_tdata (abfd
)->phdr
;
243 n_hdrs
= elf_elfheader (abfd
)->e_phnum
;
245 /* We're only interested in PT_LOAD; all necessary information
246 should be covered by that. */
247 for (i
= 0; i
< n_hdrs
; i
++)
250 bfd_vma lma
= STATE_LOAD_AT_LMA_P (sd
)
251 ? phdr
[i
].p_paddr
: phdr
[i
].p_vaddr
;
253 if (phdr
[i
].p_type
!= PT_LOAD
)
256 buf
= xmalloc (phdr
[i
].p_filesz
);
259 xprintf (callback
, "Loading segment at 0x%lx, size 0x%lx\n",
260 lma
, phdr
[i
].p_filesz
);
262 if (bfd_seek (abfd
, phdr
[i
].p_offset
, SEEK_SET
) != 0
263 || (bfd_bread (buf
, phdr
[i
].p_filesz
, abfd
) != phdr
[i
].p_filesz
))
266 "%s: could not read segment at 0x%lx, size 0x%lx\n",
267 STATE_MY_NAME (sd
), lma
, phdr
[i
].p_filesz
);
272 if (do_write (sd
, lma
, buf
, phdr
[i
].p_filesz
) != phdr
[i
].p_filesz
)
275 "%s: could not load segment at 0x%lx, size 0x%lx\n",
276 STATE_MY_NAME (sd
), lma
, phdr
[i
].p_filesz
);
287 /* Replacement for ../common/sim-hload.c:sim_load, so we can treat ELF
288 files differently. */
291 sim_load (SIM_DESC sd
, char *prog_name
, struct bfd
*prog_bfd
,
292 int from_tty ATTRIBUTE_UNUSED
)
296 if (bfd_get_flavour (prog_bfd
) != bfd_target_elf_flavour
)
298 SIM_ASSERT (STATE_MAGIC (sd
) == SIM_MAGIC_NUMBER
);
299 if (sim_analyze_program (sd
, prog_name
, prog_bfd
) != SIM_RC_OK
)
301 SIM_ASSERT (STATE_PROG_BFD (sd
) != NULL
);
303 result_bfd
= sim_load_file (sd
, STATE_MY_NAME (sd
),
307 STATE_OPEN_KIND (sd
) == SIM_OPEN_DEBUG
,
308 STATE_LOAD_AT_LMA_P (sd
),
310 if (result_bfd
== NULL
)
312 bfd_close (STATE_PROG_BFD (sd
));
313 STATE_PROG_BFD (sd
) = NULL
;
319 return cris_load_elf_file (sd
, prog_bfd
, sim_write
)
320 ? SIM_RC_OK
: SIM_RC_FAIL
;
323 /* Cover function of sim_state_free to free the cpu buffers as well. */
326 free_state (SIM_DESC sd
)
328 if (STATE_MODULES (sd
) != NULL
)
329 sim_module_uninstall (sd
);
330 sim_cpu_free_all (sd
);
334 /* BFD section iterator to find the highest and lowest allocated and
335 non-allocated section addresses (plus one). */
338 get_progbounds_iterator (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*s
, void *vp
)
340 struct progbounds
*pbp
= (struct progbounds
*) vp
;
342 if ((bfd_get_section_flags (abfd
, s
) & SEC_ALLOC
))
344 bfd_size_type sec_size
= bfd_get_section_size (s
);
345 bfd_size_type sec_start
= bfd_get_section_vma (abfd
, s
);
346 bfd_size_type sec_end
= sec_start
+ sec_size
;
348 if (sec_end
> pbp
->endmem
)
349 pbp
->endmem
= sec_end
;
351 if (sec_start
< pbp
->startmem
)
352 pbp
->startmem
= sec_start
;
354 if ((bfd_get_section_flags (abfd
, s
) & SEC_LOAD
))
356 if (sec_end
> pbp
->end_loadmem
)
357 pbp
->end_loadmem
= sec_end
;
359 else if (sec_start
< pbp
->start_nonloadmem
)
360 pbp
->start_nonloadmem
= sec_start
;
364 /* Get the program boundaries. Because not everything is covered by
365 sections in ELF, notably the program headers, we use the program
369 cris_get_progbounds (struct bfd
*abfd
, struct progbounds
*pbp
)
371 Elf_Internal_Phdr
*phdr
;
375 pbp
->startmem
= 0xffffffff;
377 pbp
->end_loadmem
= 0;
378 pbp
->start_nonloadmem
= 0xffffffff;
380 /* In case we're ever used for something other than ELF, use the
382 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
384 bfd_map_over_sections (abfd
, get_progbounds_iterator
, pbp
);
388 phdr
= elf_tdata (abfd
)->phdr
;
389 n_hdrs
= elf_elfheader (abfd
)->e_phnum
;
391 /* We're only interested in PT_LOAD; all necessary information
392 should be covered by that. */
393 for (i
= 0; i
< n_hdrs
; i
++)
395 if (phdr
[i
].p_type
!= PT_LOAD
)
398 if (phdr
[i
].p_paddr
< pbp
->startmem
)
399 pbp
->startmem
= phdr
[i
].p_paddr
;
401 if (phdr
[i
].p_paddr
+ phdr
[i
].p_memsz
> pbp
->endmem
)
402 pbp
->endmem
= phdr
[i
].p_paddr
+ phdr
[i
].p_memsz
;
404 if (phdr
[i
].p_paddr
+ phdr
[i
].p_filesz
> pbp
->end_loadmem
)
405 pbp
->end_loadmem
= phdr
[i
].p_paddr
+ phdr
[i
].p_filesz
;
407 if (phdr
[i
].p_memsz
> phdr
[i
].p_filesz
408 && phdr
[i
].p_paddr
+ phdr
[i
].p_filesz
< pbp
->start_nonloadmem
)
409 pbp
->start_nonloadmem
= phdr
[i
].p_paddr
+ phdr
[i
].p_filesz
;
413 /* Parameter communication by static variables, hmm... Oh well, for
415 static bfd_vma exec_load_addr
;
416 static bfd_vma interp_load_addr
;
417 static bfd_vma interp_start_addr
;
419 /* Supposed to mimic Linux' "NEW_AUX_ENT (AT_PHDR, load_addr + exec->e_phoff)". */
422 aux_ent_phdr (struct bfd
*ebfd
)
424 return elf_elfheader (ebfd
)->e_phoff
+ exec_load_addr
;
427 /* We just pass on the header info; we don't have our own idea of the
428 program header entry size. */
431 aux_ent_phent (struct bfd
*ebfd
)
433 return elf_elfheader (ebfd
)->e_phentsize
;
436 /* Like "NEW_AUX_ENT(AT_PHNUM, exec->e_phnum)". */
439 aux_ent_phnum (struct bfd
*ebfd
)
441 return elf_elfheader (ebfd
)->e_phnum
;
444 /* Like "NEW_AUX_ENT(AT_BASE, interp_load_addr)". */
447 aux_ent_base (struct bfd
*ebfd
)
449 return interp_load_addr
;
452 /* Like "NEW_AUX_ENT(AT_ENTRY, exec->e_entry)". */
455 aux_ent_entry (struct bfd
*ebfd
)
457 ASSERT (elf_elfheader (ebfd
)->e_entry
== bfd_get_start_address (ebfd
));
458 return elf_elfheader (ebfd
)->e_entry
;
461 /* Helper for cris_handle_interpreter: like sim_write, but load at
462 interp_load_addr offset. */
465 cris_write_interp (SIM_DESC sd
, SIM_ADDR mem
, unsigned char *buf
, int length
)
467 return sim_write (sd
, mem
+ interp_load_addr
, buf
, length
);
470 /* Cater to the presence of an interpreter: load it and set
471 interp_start_addr. Return FALSE if there was an error, TRUE if
472 everything went fine, including an interpreter being absent and
473 the program being in a non-ELF format. */
476 cris_handle_interpreter (SIM_DESC sd
, struct bfd
*abfd
)
483 bfd_boolean ok
= FALSE
;
484 Elf_Internal_Phdr
*phdr
;
486 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
489 phdr
= elf_tdata (abfd
)->phdr
;
490 n_hdrs
= aux_ent_phnum (abfd
);
492 /* Check the program headers for presence of an interpreter. */
493 for (i
= 0; i
< n_hdrs
; i
++)
496 bfd_size_type interpsiz
, interp_filesiz
;
497 struct progbounds interp_bounds
;
499 if (phdr
[i
].p_type
!= PT_INTERP
)
502 /* Get the name of the interpreter, prepended with the sysroot
503 (empty if absent). */
504 interplen
= phdr
[i
].p_filesz
;
505 interp
= xmalloc (interplen
+ strlen (simulator_sysroot
));
506 strcpy (interp
, simulator_sysroot
);
508 /* Read in the name. */
509 if (bfd_seek (abfd
, phdr
[i
].p_offset
, SEEK_SET
) != 0
510 || (bfd_bread (interp
+ strlen (simulator_sysroot
), interplen
, abfd
)
512 goto interpname_failed
;
514 /* Like Linux, require the string to be 0-terminated. */
515 if (interp
[interplen
+ strlen (simulator_sysroot
) - 1] != 0)
516 goto interpname_failed
;
518 /* Inspect the interpreter. */
519 ibfd
= bfd_openr (interp
, STATE_TARGET (sd
));
521 goto interpname_failed
;
523 /* The interpreter is at leat something readable to BFD; make
524 sure it's an ELF non-archive file. */
525 if (!bfd_check_format (ibfd
, bfd_object
)
526 || bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
529 /* Check the layout of the interpreter. */
530 cris_get_progbounds (ibfd
, &interp_bounds
);
532 /* Round down to pagesize the start page and up the endpage.
533 Don't round the *load and *nonload members. */
534 interp_bounds
.startmem
&= ~8191;
535 interp_bounds
.endmem
= (interp_bounds
.endmem
+ 8191) & ~8191;
537 /* Until we need a more dynamic solution, assume we can put the
538 interpreter at this fixed location. NB: this is not what
539 happens for Linux 2008-12-28, but it could and might and
541 interp_load_addr
= 0x40000;
542 interpsiz
= interp_bounds
.endmem
- interp_bounds
.startmem
;
543 interp_filesiz
= interp_bounds
.end_loadmem
- interp_bounds
.startmem
;
545 /* If we have a non-DSO or interpreter starting at the wrong
547 if (interp_bounds
.startmem
!= 0
548 || interpsiz
+ interp_load_addr
>= exec_load_addr
)
551 /* We don't have the API to get the address of a simulator
552 memory area, so we go via a temporary area. Luckily, the
553 interpreter is supposed to be small, less than 0x40000
555 sim_do_commandf (sd
, "memory region 0x%lx,0x%lx",
556 interp_load_addr
, interpsiz
);
558 /* Now that memory for the interpreter is defined, load it. */
559 if (!cris_load_elf_file (sd
, ibfd
, cris_write_interp
))
562 /* It's no use setting STATE_START_ADDR, because it gets
563 overwritten by a sim_analyze_program call in sim_load. Let's
564 just store it locally. */
566 = (bfd_get_start_address (ibfd
)
567 - interp_bounds
.startmem
+ interp_load_addr
);
569 /* Linux cares only about the first PT_INTERP, so let's ignore
574 /* Register R10 should hold 0 at static start (no finifunc), but
575 that's the default, so don't bother. */
587 "%s: could not load ELF interpreter `%s' for program `%s'\n",
589 interp
== NULL
? "(what's-its-name)" : interp
,
590 bfd_get_filename (abfd
));
595 /* Create an instance of the simulator. */
598 sim_open (SIM_OPEN_KIND kind
, host_callback
*callback
, struct bfd
*abfd
,
604 USI endmem
= CRIS_DEFAULT_MEM_SIZE
;
607 SIM_DESC sd
= sim_state_alloc (kind
, callback
);
609 static const struct auxv_entries_s
612 USI (*efn
) (struct bfd
*ebfd
);
616 #define AUX_ENT(a, b) {a, NULL, b}
617 #define AUX_ENTF(a, f) {a, f, 0}
618 AUX_ENT (AT_HWCAP
, 0),
619 AUX_ENT (AT_PAGESZ
, 8192),
620 AUX_ENT (AT_CLKTCK
, 100),
621 AUX_ENTF (AT_PHDR
, aux_ent_phdr
),
622 AUX_ENTF (AT_PHENT
, aux_ent_phent
),
623 AUX_ENTF (AT_PHNUM
, aux_ent_phnum
),
624 AUX_ENTF (AT_BASE
, aux_ent_base
),
625 AUX_ENT (AT_FLAGS
, 0),
626 AUX_ENTF (AT_ENTRY
, aux_ent_entry
),
628 /* Or is root better? Maybe have it settable? */
629 AUX_ENT (AT_UID
, 500),
630 AUX_ENT (AT_EUID
, 500),
631 AUX_ENT (AT_GID
, 500),
632 AUX_ENT (AT_EGID
, 500),
633 AUX_ENT (AT_SECURE
, 0),
637 /* Can't initialize to "" below. It's either a GCC bug in old
638 releases (up to and including 2.95.3 (.4 in debian) or a bug in the
639 standard ;-) that the rest of the elements won't be initialized. */
640 bfd_byte sp_init
[4] = {0, 0, 0, 0};
642 /* The cpu data is kept in a separately allocated chunk of memory. */
643 if (sim_cpu_alloc_all (sd
, 1, cgen_cpu_max_extra_bytes ()) != SIM_RC_OK
)
649 if (sim_pre_argv_init (sd
, argv
[0]) != SIM_RC_OK
)
655 /* getopt will print the error message so we just have to exit if this fails.
656 FIXME: Hmmm... in the case of gdb we need getopt to call
658 if (sim_parse_args (sd
, argv
) != SIM_RC_OK
)
664 /* If we have a binary program, endianness-setting would not be taken
665 from elsewhere unfortunately, so set it here. At the time of this
666 writing, it isn't used until sim_config, but that might change so
667 set it here before memory is defined or touched. */
668 current_target_byte_order
= LITTLE_ENDIAN
;
670 /* check for/establish the reference program image */
671 if (sim_analyze_program (sd
,
672 (STATE_PROG_ARGV (sd
) != NULL
673 ? *STATE_PROG_ARGV (sd
)
677 /* When there's an error, sim_analyze_program has already output
678 a message. Let's just clarify it, as "not an object file"
679 perhaps doesn't ring a bell. */
680 sim_io_eprintf (sd
, "(not a CRIS program)\n");
685 /* We might get called with the caller expecting us to get hold of
686 the bfd for ourselves, which would happen at the
687 sim_analyze_program call above. */
689 abfd
= STATE_PROG_BFD (sd
);
691 if (bfd_get_arch (abfd
) == bfd_arch_unknown
)
693 if (STATE_PROG_ARGV (sd
) != NULL
)
694 sim_io_eprintf (sd
, "%s: `%s' is not a CRIS program\n",
695 STATE_MY_NAME (sd
), *STATE_PROG_ARGV (sd
));
697 sim_io_eprintf (sd
, "%s: program to be run is not a CRIS program\n",
703 /* For CRIS simulator-specific use, we need to find out the bounds of
704 the program as well, which is not done by sim_analyze_program
708 struct progbounds pb
;
710 /* The sections should now be accessible using bfd functions. */
711 cris_get_progbounds (abfd
, &pb
);
713 /* We align the area that the program uses to page boundaries. */
714 startmem
= pb
.startmem
& ~8191;
716 endmem
= (endbrk
+ 8191) & ~8191;
719 /* Find out how much room is needed for the environment and argv, create
720 that memory and fill it. Only do this when there's a program
722 if (abfd
!= NULL
&& !cris_bare_iron
)
724 char *name
= bfd_get_filename (abfd
);
725 char **my_environ
= GET_ENVIRON ();
726 /* We use these maps to give the same behavior as the old xsim
728 USI envtop
= 0x40000000;
729 USI stacktop
= 0x3e000000;
732 int len
= strlen (name
) + 1;
736 char **prog_argv
= STATE_PROG_ARGV (sd
);
738 /* All CPU:s have the same memory map, apparently. */
739 SIM_CPU
*cpu
= STATE_CPU (sd
, 0);
743 /* Count in the environment as well. */
744 for (envc
= 0; my_environ
[envc
] != NULL
; envc
++)
745 len
+= strlen (my_environ
[envc
]) + 1;
747 for (i
= 0; prog_argv
[i
] != NULL
; my_argc
++, i
++)
748 len
+= strlen (prog_argv
[i
]) + 1;
750 envstart
= (envtop
- len
) & ~8191;
752 /* Create read-only block for the environment strings. */
753 sim_core_attach (sd
, NULL
, 0, access_read
, 0,
754 envstart
, (len
+ 8191) & ~8191,
757 /* This shouldn't happen. */
758 if (envstart
< stacktop
)
759 stacktop
= envstart
- 64 * 8192;
763 /* Note that the linux kernel does not correctly compute the storage
764 needs for the static-exe AUX vector. */
766 csp
-= sizeof (auxv_entries
) / sizeof (auxv_entries
[0]) * 4 * 2;
768 csp
-= (envc
+ 1) * 4;
769 csp
-= (my_argc
+ 1) * 4;
772 /* Write the target representation of the start-up-value for the
773 stack-pointer suitable for register initialization below. */
774 bfd_putl32 (csp
, sp_init
);
776 /* If we make this 1M higher; say 8192*1024, we have to take
777 special precautions for pthreads, because pthreads assumes that
778 the memory that low isn't mmapped, and that it can mmap it
779 without fallback in case of failure (and we fail ungracefully
780 long before *that*: the memory isn't accounted for in our mmap
782 stack_low
= (csp
- (7168*1024)) & ~8191;
784 stacklen
= stacktop
- stack_low
;
786 /* Tee hee, we have an executable stack. Well, it's necessary to
787 test GCC trampolines... */
788 sim_core_attach (sd
, NULL
, 0, access_read_write_exec
, 0,
792 epp
= epp0
= envstart
;
794 /* Can't use sim_core_write_unaligned_4 without everything
795 initialized when tracing, and then these writes would get into
797 #define write_dword(addr, data) \
802 bfd_putl32 (data_, buf); \
803 if (sim_core_write_buffer (sd, cpu, 0, buf, addr_, 4) != 4) \
808 write_dword (csp
, my_argc
);
811 for (i
= 0; i
< my_argc
; i
++, csp
+= 4)
813 size_t strln
= strlen (prog_argv
[i
]) + 1;
815 if (sim_core_write_buffer (sd
, cpu
, 0, prog_argv
[i
], epp
, strln
)
819 write_dword (csp
, envstart
+ epp
- epp0
);
823 write_dword (csp
, 0);
826 for (i
= 0; i
< envc
; i
++, csp
+= 4)
828 unsigned int strln
= strlen (my_environ
[i
]) + 1;
830 if (sim_core_write_buffer (sd
, cpu
, 0, my_environ
[i
], epp
, strln
)
834 write_dword (csp
, envstart
+ epp
- epp0
);
838 write_dword (csp
, 0);
841 /* The load address of the executable could presumably be
842 different than the lowest used memory address, but let's
843 stick to simplicity until needed. And
844 cris_handle_interpreter might change startmem and endmem, so
846 exec_load_addr
= startmem
;
848 if (!cris_handle_interpreter (sd
, abfd
))
851 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
852 for (i
= 0; i
< sizeof (auxv_entries
) / sizeof (auxv_entries
[0]); i
++)
854 write_dword (csp
, auxv_entries
[i
].id
);
855 write_dword (csp
+ 4,
856 auxv_entries
[i
].efn
!= NULL
857 ? (*auxv_entries
[i
].efn
) (abfd
)
858 : auxv_entries
[i
].val
);
863 /* Allocate core managed memory if none specified by user. */
864 if (sim_core_read_buffer (sd
, NULL
, read_map
, &c
, startmem
, 1) == 0)
865 sim_do_commandf (sd
, "memory region 0x%lx,0x%lx", startmem
,
868 /* Allocate simulator I/O managed memory if none specified by user. */
869 if (cris_have_900000xxif
)
871 if (sim_core_read_buffer (sd
, NULL
, read_map
, &c
, 0x90000000, 1) == 0)
872 sim_core_attach (sd
, NULL
, 0, access_write
, 0, 0x90000000, 0x100,
873 0, &cris_devices
, NULL
);
877 printf_filtered
) (callback
,
878 "Seeing --cris-900000xx with memory defined there\n");
883 /* Establish any remaining configuration options. */
884 if (sim_config (sd
) != SIM_RC_OK
)
891 if (sim_post_argv_init (sd
) != SIM_RC_OK
)
897 /* Open a copy of the cpu descriptor table. */
899 CGEN_CPU_DESC cd
= cris_cgen_cpu_open_1 (STATE_ARCHITECTURE (sd
)->printable_name
,
901 for (i
= 0; i
< MAX_NR_PROCESSORS
; ++i
)
903 SIM_CPU
*cpu
= STATE_CPU (sd
, i
);
904 CPU_CPU_DESC (cpu
) = cd
;
905 CPU_DISASSEMBLER (cpu
) = cris_disassemble_insn
;
907 /* See cris_option_handler for the reason why this is needed. */
908 CPU_CRIS_MISC_PROFILE (cpu
)->flags
= STATE_TRACE_FLAGS (sd
)[0];
910 /* Set SP to the stack we allocated above. */
911 (* CPU_REG_STORE (cpu
)) (cpu
, H_GR_SP
, (char *) sp_init
, 4);
913 /* Set the simulator environment data. */
914 cpu
->highest_mmapped_page
= NULL
;
915 cpu
->endmem
= endmem
;
916 cpu
->endbrk
= endbrk
;
917 cpu
->stack_low
= stack_low
;
921 cpu
->max_threadid
= 0;
922 cpu
->thread_data
= NULL
;
923 memset (cpu
->sighandler
, 0, sizeof (cpu
->sighandler
));
924 cpu
->make_thread_cpu_data
= NULL
;
925 cpu
->thread_cpu_data_size
= 0;
927 cpu
->deliver_interrupt
= NULL
;
931 /* Always be cycle-accurate and call before/after functions if
933 sim_profile_set_option (sd
, "-model", PROFILE_MODEL_IDX
, "on");
937 /* Initialize various cgen things not done by common framework.
938 Must be done after cris_cgen_cpu_open. */
941 /* Store in a global so things like cris_dump_regs can be invoked
942 from the gdb command line. */
945 cris_set_callbacks (callback
);
951 sim_close (SIM_DESC sd
, int quitting ATTRIBUTE_UNUSED
)
953 cris_cgen_cpu_close (CPU_CPU_DESC (STATE_CPU (sd
, 0)));
954 sim_module_uninstall (sd
);
958 sim_create_inferior (SIM_DESC sd
, struct bfd
*abfd
,
959 char **argv ATTRIBUTE_UNUSED
,
960 char **envp ATTRIBUTE_UNUSED
)
962 SIM_CPU
*current_cpu
= STATE_CPU (sd
, 0);
966 addr
= interp_start_addr
!= 0
967 ? interp_start_addr
: bfd_get_start_address (abfd
);
970 sim_pc_set (current_cpu
, addr
);
972 /* Other simulators have #if 0:d code that says
973 STATE_ARGV (sd) = sim_copy_argv (argv);
974 STATE_ENVP (sd) = sim_copy_argv (envp);
975 Enabling that gives you not-found link-errors for sim_copy_argv.
976 FIXME: Do archaeology to find out more. */
982 sim_do_command (SIM_DESC sd
, char *cmd
)
984 if (sim_args_command (sd
, cmd
) != SIM_RC_OK
)
985 sim_io_eprintf (sd
, "Unknown command `%s'\n", cmd
);
988 /* Disassemble an instruction. */
991 cris_disassemble_insn (SIM_CPU
*cpu
,
992 const CGEN_INSN
*insn ATTRIBUTE_UNUSED
,
993 const ARGBUF
*abuf ATTRIBUTE_UNUSED
,
996 disassembler_ftype pinsn
;
997 struct disassemble_info disasm_info
;
999 SIM_DESC sd
= CPU_STATE (cpu
);
1001 sfile
.buffer
= sfile
.current
= buf
;
1002 INIT_DISASSEMBLE_INFO (disasm_info
, (FILE *) &sfile
,
1003 (fprintf_ftype
) sim_disasm_sprintf
);
1004 disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1005 disasm_info
.read_memory_func
= sim_disasm_read_memory
;
1006 disasm_info
.memory_error_func
= sim_disasm_perror_memory
;
1007 disasm_info
.application_data
= (PTR
) cpu
;
1008 pinsn
= cris_get_disassembler (STATE_PROG_BFD (sd
));
1009 (*pinsn
) (pc
, &disasm_info
);