1 /* Main simulator entry points specific to the CRIS.
2 Copyright (C) 2004-2015 Free Software Foundation, Inc.
3 Contributed by Axis Communications.
5 This file is part of the GNU simulators.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 /* Based on the fr30 file, mixing in bits from the i960 and pruning of
24 #include "libiberty.h"
33 #include "sim-options.h"
36 /* Apparently the autoconf bits are missing (though HAVE_ENVIRON is used
37 in other dirs; also lacking there). Patch around it for major systems. */
38 #if defined (HAVE_ENVIRON) || defined (__GLIBC__)
39 extern char **environ
;
40 #define GET_ENVIRON() environ
42 char *missing_environ
[] = { "SHELL=/bin/sh", "PATH=/bin:/usr/bin", NULL
};
43 #define GET_ENVIRON() missing_environ
46 /* Used with get_progbounds to find out how much memory is needed for the
47 program. We don't want to allocate more, since that could mask
48 invalid memory accesses program bugs. */
56 static void free_state (SIM_DESC
);
57 static void get_progbounds_iterator (bfd
*, asection
*, void *);
58 static SIM_RC
cris_option_handler (SIM_DESC
, sim_cpu
*, int, char *, int);
60 /* Since we don't build the cgen-opcode table, we use the old
62 static CGEN_DISASSEMBLER cris_disassemble_insn
;
64 /* By default, we set up stack and environment variables like the Linux
66 static char cris_bare_iron
= 0;
68 /* Whether 0x9000000xx have simulator-specific meanings. */
69 char cris_have_900000xxif
= 0;
71 /* Used to optionally override the default start address of the
73 static USI cris_start_address
= 0xffffffffu
;
75 /* Used to optionally add offsets to the loaded image and its start
76 address. (Not used for the interpreter of dynamically loaded
77 programs or the DSO:s.) */
78 static int cris_program_offset
= 0;
80 /* What to do when we face a more or less unknown syscall. */
81 enum cris_unknown_syscall_action_type cris_unknown_syscall_action
82 = CRIS_USYSC_MSG_STOP
;
84 /* Records simulator descriptor so utilities like cris_dump_regs can be
86 SIM_DESC current_state
;
88 /* CRIS-specific options. */
90 OPTION_CRIS_STATS
= OPTION_START
,
93 OPTION_CRIS_PROGRAM_OFFSET
,
94 OPTION_CRIS_STARTADDR
,
95 OPTION_CRIS_900000XXIF
,
96 OPTION_CRIS_UNKNOWN_SYSCALL
99 static const OPTION cris_options
[] =
101 { {"cris-cycles", required_argument
, NULL
, OPTION_CRIS_STATS
},
102 '\0', "basic|unaligned|schedulable|all",
103 "Dump execution statistics",
104 cris_option_handler
, NULL
},
105 { {"cris-trace", required_argument
, NULL
, OPTION_CRIS_TRACE
},
107 "Emit trace information while running",
108 cris_option_handler
, NULL
},
109 { {"cris-naked", no_argument
, NULL
, OPTION_CRIS_NAKED
},
110 '\0', NULL
, "Don't set up stack and environment",
111 cris_option_handler
, NULL
},
112 { {"cris-900000xx", no_argument
, NULL
, OPTION_CRIS_900000XXIF
},
113 '\0', NULL
, "Define addresses at 0x900000xx with simulator semantics",
114 cris_option_handler
, NULL
},
115 { {"cris-unknown-syscall", required_argument
, NULL
,
116 OPTION_CRIS_UNKNOWN_SYSCALL
},
117 '\0', "stop|enosys|enosys-quiet", "Action at an unknown system call",
118 cris_option_handler
, NULL
},
119 { {"cris-program-offset", required_argument
, NULL
,
120 OPTION_CRIS_PROGRAM_OFFSET
},
122 "Offset image addresses and default start address of a program",
123 cris_option_handler
},
124 { {"cris-start-address", required_argument
, NULL
, OPTION_CRIS_STARTADDR
},
125 '\0', "ADDRESS", "Set start address",
126 cris_option_handler
},
127 { {NULL
, no_argument
, NULL
, 0}, '\0', NULL
, NULL
, NULL
, NULL
}
130 /* Handle CRIS-specific options. */
133 cris_option_handler (SIM_DESC sd
, sim_cpu
*cpu ATTRIBUTE_UNUSED
, int opt
,
134 char *arg
, int is_command ATTRIBUTE_UNUSED
)
136 /* The options are CRIS-specific, but cpu-specific option-handling is
137 broken; required to being with "--cpu0-". We store the flags in an
138 unused field in the global state structure and move the flags over
139 to the module-specific CPU data when we store things in the
140 cpu-specific structure. */
141 char *tracefp
= STATE_TRACE_FLAGS (sd
);
144 switch ((CRIS_OPTIONS
) opt
)
146 case OPTION_CRIS_STATS
:
147 if (strcmp (arg
, "basic") == 0)
148 *tracefp
= FLAG_CRIS_MISC_PROFILE_SIMPLE
;
149 else if (strcmp (arg
, "unaligned") == 0)
151 = (FLAG_CRIS_MISC_PROFILE_UNALIGNED
152 | FLAG_CRIS_MISC_PROFILE_SIMPLE
);
153 else if (strcmp (arg
, "schedulable") == 0)
155 = (FLAG_CRIS_MISC_PROFILE_SCHEDULABLE
156 | FLAG_CRIS_MISC_PROFILE_SIMPLE
);
157 else if (strcmp (arg
, "all") == 0)
158 *tracefp
= FLAG_CRIS_MISC_PROFILE_ALL
;
161 /* Beware; the framework does not handle the error case;
162 we have to do it ourselves. */
163 sim_io_eprintf (sd
, "Unknown option `--cris-cycles=%s'\n", arg
);
168 case OPTION_CRIS_TRACE
:
169 if (strcmp (arg
, "basic") == 0)
170 *tracefp
|= FLAG_CRIS_MISC_PROFILE_XSIM_TRACE
;
173 sim_io_eprintf (sd
, "Unknown option `--cris-trace=%s'\n", arg
);
178 case OPTION_CRIS_NAKED
:
182 case OPTION_CRIS_900000XXIF
:
183 cris_have_900000xxif
= 1;
186 case OPTION_CRIS_STARTADDR
:
188 cris_start_address
= (USI
) strtoul (chp
, &chp
, 0);
190 if (errno
!= 0 || *chp
!= 0)
192 sim_io_eprintf (sd
, "Invalid option `--cris-start-address=%s'\n",
198 case OPTION_CRIS_PROGRAM_OFFSET
:
200 cris_program_offset
= (int) strtol (chp
, &chp
, 0);
202 if (errno
!= 0 || *chp
!= 0)
204 sim_io_eprintf (sd
, "Invalid option `--cris-program-offset=%s'\n",
210 case OPTION_CRIS_UNKNOWN_SYSCALL
:
211 if (strcmp (arg
, "enosys") == 0)
212 cris_unknown_syscall_action
= CRIS_USYSC_MSG_ENOSYS
;
213 else if (strcmp (arg
, "enosys-quiet") == 0)
214 cris_unknown_syscall_action
= CRIS_USYSC_QUIET_ENOSYS
;
215 else if (strcmp (arg
, "stop") == 0)
216 cris_unknown_syscall_action
= CRIS_USYSC_MSG_STOP
;
219 sim_io_eprintf (sd
, "Unknown option `--cris-unknown-syscall=%s'\n",
226 /* We'll actually never get here; the caller handles the error
228 sim_io_eprintf (sd
, "Unknown option `%s'\n", arg
);
232 /* Imply --profile-model=on. */
233 return sim_profile_set_option (sd
, "-model", PROFILE_MODEL_IDX
, "on");
236 /* FIXME: Remove these, globalize those in sim-load.c, move elsewhere. */
239 xprintf (host_callback
*callback
, const char *fmt
, ...)
245 (*callback
->vprintf_filtered
) (callback
, fmt
, ap
);
251 eprintf (host_callback
*callback
, const char *fmt
, ...)
257 (*callback
->evprintf_filtered
) (callback
, fmt
, ap
);
262 /* An ELF-specific simplified ../common/sim-load.c:sim_load_file,
263 using the program headers, not sections, in order to make sure that
264 the program headers themeselves are also loaded. The caller is
265 responsible for asserting that ABFD is an ELF file. */
268 cris_load_elf_file (SIM_DESC sd
, struct bfd
*abfd
, sim_write_fn do_write
)
270 Elf_Internal_Phdr
*phdr
;
273 bfd_boolean verbose
= STATE_OPEN_KIND (sd
) == SIM_OPEN_DEBUG
;
274 host_callback
*callback
= STATE_CALLBACK (sd
);
276 phdr
= elf_tdata (abfd
)->phdr
;
277 n_hdrs
= elf_elfheader (abfd
)->e_phnum
;
279 /* We're only interested in PT_LOAD; all necessary information
280 should be covered by that. */
281 for (i
= 0; i
< n_hdrs
; i
++)
284 bfd_vma lma
= STATE_LOAD_AT_LMA_P (sd
)
285 ? phdr
[i
].p_paddr
: phdr
[i
].p_vaddr
;
287 if (phdr
[i
].p_type
!= PT_LOAD
)
290 buf
= xmalloc (phdr
[i
].p_filesz
);
293 xprintf (callback
, "Loading segment at 0x%lx, size 0x%lx\n",
294 lma
, phdr
[i
].p_filesz
);
296 if (bfd_seek (abfd
, phdr
[i
].p_offset
, SEEK_SET
) != 0
297 || (bfd_bread (buf
, phdr
[i
].p_filesz
, abfd
) != phdr
[i
].p_filesz
))
300 "%s: could not read segment at 0x%lx, size 0x%lx\n",
301 STATE_MY_NAME (sd
), lma
, phdr
[i
].p_filesz
);
306 if (do_write (sd
, lma
, buf
, phdr
[i
].p_filesz
) != phdr
[i
].p_filesz
)
309 "%s: could not load segment at 0x%lx, size 0x%lx\n",
310 STATE_MY_NAME (sd
), lma
, phdr
[i
].p_filesz
);
321 /* Helper for sim_load (needed just for ELF files): like sim_write,
322 but offset load at cris_program_offset offset. */
325 cris_program_offset_write (SIM_DESC sd
, SIM_ADDR mem
, unsigned char *buf
,
328 return sim_write (sd
, mem
+ cris_program_offset
, buf
, length
);
331 /* Replacement for ../common/sim-hload.c:sim_load, so we can treat ELF
332 files differently. */
335 sim_load (SIM_DESC sd
, const char *prog_name
, struct bfd
*prog_bfd
,
336 int from_tty ATTRIBUTE_UNUSED
)
340 if (bfd_get_flavour (prog_bfd
) != bfd_target_elf_flavour
)
342 SIM_ASSERT (STATE_MAGIC (sd
) == SIM_MAGIC_NUMBER
);
343 if (sim_analyze_program (sd
, prog_name
, prog_bfd
) != SIM_RC_OK
)
345 SIM_ASSERT (STATE_PROG_BFD (sd
) != NULL
);
347 result_bfd
= sim_load_file (sd
, STATE_MY_NAME (sd
),
351 STATE_OPEN_KIND (sd
) == SIM_OPEN_DEBUG
,
352 STATE_LOAD_AT_LMA_P (sd
),
354 if (result_bfd
== NULL
)
356 bfd_close (STATE_PROG_BFD (sd
));
357 STATE_PROG_BFD (sd
) = NULL
;
363 return cris_load_elf_file (sd
, prog_bfd
, cris_program_offset_write
)
364 ? SIM_RC_OK
: SIM_RC_FAIL
;
367 /* Cover function of sim_state_free to free the cpu buffers as well. */
370 free_state (SIM_DESC sd
)
372 if (STATE_MODULES (sd
) != NULL
)
373 sim_module_uninstall (sd
);
374 sim_cpu_free_all (sd
);
378 /* Helper struct for cris_set_section_offset_iterator. */
386 /* BFD section iterator to offset the LMA and VMA. */
389 cris_set_section_offset_iterator (bfd
*abfd
, asection
*s
, void *vp
)
391 struct offsetinfo
*p
= (struct offsetinfo
*) vp
;
393 int offset
= p
->offset
;
395 if ((bfd_get_section_flags (abfd
, s
) & SEC_ALLOC
))
397 bfd_vma vma
= bfd_get_section_vma (abfd
, s
);
399 bfd_set_section_vma (abfd
, s
, vma
+ offset
);
402 /* This seems clumsy and inaccurate, but let's stick to doing it the
403 same way as sim_analyze_program for consistency. */
404 if (strcmp (bfd_get_section_name (abfd
, s
), ".text") == 0)
405 STATE_TEXT_START (sd
) = bfd_get_section_vma (abfd
, s
);
408 /* Adjust the start-address, LMA and VMA of a SD. Must be called
409 after sim_analyze_program. */
412 cris_offset_sections (SIM_DESC sd
, int offset
)
415 struct bfd
*abfd
= STATE_PROG_BFD (sd
);
417 struct offsetinfo oi
;
419 /* Only happens for usage error. */
426 bfd_map_over_sections (abfd
, cris_set_section_offset_iterator
, &oi
);
427 ret
= bfd_set_start_address (abfd
, bfd_get_start_address (abfd
) + offset
);
429 STATE_START_ADDR (sd
) = bfd_get_start_address (abfd
);
432 /* BFD section iterator to find the highest and lowest allocated and
433 non-allocated section addresses (plus one). */
436 get_progbounds_iterator (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*s
, void *vp
)
438 struct progbounds
*pbp
= (struct progbounds
*) vp
;
440 if ((bfd_get_section_flags (abfd
, s
) & SEC_ALLOC
))
442 bfd_size_type sec_size
= bfd_get_section_size (s
);
443 bfd_size_type sec_start
= bfd_get_section_vma (abfd
, s
);
444 bfd_size_type sec_end
= sec_start
+ sec_size
;
446 if (sec_end
> pbp
->endmem
)
447 pbp
->endmem
= sec_end
;
449 if (sec_start
< pbp
->startmem
)
450 pbp
->startmem
= sec_start
;
452 if ((bfd_get_section_flags (abfd
, s
) & SEC_LOAD
))
454 if (sec_end
> pbp
->end_loadmem
)
455 pbp
->end_loadmem
= sec_end
;
457 else if (sec_start
< pbp
->start_nonloadmem
)
458 pbp
->start_nonloadmem
= sec_start
;
462 /* Get the program boundaries. Because not everything is covered by
463 sections in ELF, notably the program headers, we use the program
467 cris_get_progbounds (struct bfd
*abfd
, struct progbounds
*pbp
)
469 Elf_Internal_Phdr
*phdr
;
473 pbp
->startmem
= 0xffffffff;
475 pbp
->end_loadmem
= 0;
476 pbp
->start_nonloadmem
= 0xffffffff;
478 /* In case we're ever used for something other than ELF, use the
480 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
482 bfd_map_over_sections (abfd
, get_progbounds_iterator
, pbp
);
486 phdr
= elf_tdata (abfd
)->phdr
;
487 n_hdrs
= elf_elfheader (abfd
)->e_phnum
;
489 /* We're only interested in PT_LOAD; all necessary information
490 should be covered by that. */
491 for (i
= 0; i
< n_hdrs
; i
++)
493 if (phdr
[i
].p_type
!= PT_LOAD
)
496 if (phdr
[i
].p_paddr
< pbp
->startmem
)
497 pbp
->startmem
= phdr
[i
].p_paddr
;
499 if (phdr
[i
].p_paddr
+ phdr
[i
].p_memsz
> pbp
->endmem
)
500 pbp
->endmem
= phdr
[i
].p_paddr
+ phdr
[i
].p_memsz
;
502 if (phdr
[i
].p_paddr
+ phdr
[i
].p_filesz
> pbp
->end_loadmem
)
503 pbp
->end_loadmem
= phdr
[i
].p_paddr
+ phdr
[i
].p_filesz
;
505 if (phdr
[i
].p_memsz
> phdr
[i
].p_filesz
506 && phdr
[i
].p_paddr
+ phdr
[i
].p_filesz
< pbp
->start_nonloadmem
)
507 pbp
->start_nonloadmem
= phdr
[i
].p_paddr
+ phdr
[i
].p_filesz
;
511 /* Parameter communication by static variables, hmm... Oh well, for
513 static bfd_vma exec_load_addr
;
514 static bfd_vma interp_load_addr
;
515 static bfd_vma interp_start_addr
;
517 /* Supposed to mimic Linux' "NEW_AUX_ENT (AT_PHDR, load_addr + exec->e_phoff)". */
520 aux_ent_phdr (struct bfd
*ebfd
)
522 return elf_elfheader (ebfd
)->e_phoff
+ exec_load_addr
;
525 /* We just pass on the header info; we don't have our own idea of the
526 program header entry size. */
529 aux_ent_phent (struct bfd
*ebfd
)
531 return elf_elfheader (ebfd
)->e_phentsize
;
534 /* Like "NEW_AUX_ENT(AT_PHNUM, exec->e_phnum)". */
537 aux_ent_phnum (struct bfd
*ebfd
)
539 return elf_elfheader (ebfd
)->e_phnum
;
542 /* Like "NEW_AUX_ENT(AT_BASE, interp_load_addr)". */
545 aux_ent_base (struct bfd
*ebfd
)
547 return interp_load_addr
;
550 /* Like "NEW_AUX_ENT(AT_ENTRY, exec->e_entry)". */
553 aux_ent_entry (struct bfd
*ebfd
)
555 ASSERT (elf_elfheader (ebfd
)->e_entry
== bfd_get_start_address (ebfd
));
556 return elf_elfheader (ebfd
)->e_entry
;
559 /* Helper for cris_handle_interpreter: like sim_write, but load at
560 interp_load_addr offset. */
563 cris_write_interp (SIM_DESC sd
, SIM_ADDR mem
, unsigned char *buf
, int length
)
565 return sim_write (sd
, mem
+ interp_load_addr
, buf
, length
);
568 /* Cater to the presence of an interpreter: load it and set
569 interp_start_addr. Return FALSE if there was an error, TRUE if
570 everything went fine, including an interpreter being absent and
571 the program being in a non-ELF format. */
574 cris_handle_interpreter (SIM_DESC sd
, struct bfd
*abfd
)
581 bfd_boolean ok
= FALSE
;
582 Elf_Internal_Phdr
*phdr
;
584 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
587 phdr
= elf_tdata (abfd
)->phdr
;
588 n_hdrs
= aux_ent_phnum (abfd
);
590 /* Check the program headers for presence of an interpreter. */
591 for (i
= 0; i
< n_hdrs
; i
++)
594 bfd_size_type interpsiz
, interp_filesiz
;
595 struct progbounds interp_bounds
;
597 if (phdr
[i
].p_type
!= PT_INTERP
)
600 /* Get the name of the interpreter, prepended with the sysroot
601 (empty if absent). */
602 interplen
= phdr
[i
].p_filesz
;
603 interp
= xmalloc (interplen
+ strlen (simulator_sysroot
));
604 strcpy (interp
, simulator_sysroot
);
606 /* Read in the name. */
607 if (bfd_seek (abfd
, phdr
[i
].p_offset
, SEEK_SET
) != 0
608 || (bfd_bread (interp
+ strlen (simulator_sysroot
), interplen
, abfd
)
610 goto interpname_failed
;
612 /* Like Linux, require the string to be 0-terminated. */
613 if (interp
[interplen
+ strlen (simulator_sysroot
) - 1] != 0)
614 goto interpname_failed
;
616 /* Inspect the interpreter. */
617 ibfd
= bfd_openr (interp
, STATE_TARGET (sd
));
619 goto interpname_failed
;
621 /* The interpreter is at least something readable to BFD; make
622 sure it's an ELF non-archive file. */
623 if (!bfd_check_format (ibfd
, bfd_object
)
624 || bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
627 /* Check the layout of the interpreter. */
628 cris_get_progbounds (ibfd
, &interp_bounds
);
630 /* Round down to pagesize the start page and up the endpage.
631 Don't round the *load and *nonload members. */
632 interp_bounds
.startmem
&= ~8191;
633 interp_bounds
.endmem
= (interp_bounds
.endmem
+ 8191) & ~8191;
635 /* Until we need a more dynamic solution, assume we can put the
636 interpreter at this fixed location. NB: this is not what
637 happens for Linux 2008-12-28, but it could and might and
639 interp_load_addr
= 0x40000;
640 interpsiz
= interp_bounds
.endmem
- interp_bounds
.startmem
;
641 interp_filesiz
= interp_bounds
.end_loadmem
- interp_bounds
.startmem
;
643 /* If we have a non-DSO or interpreter starting at the wrong
645 if (interp_bounds
.startmem
!= 0
646 || interpsiz
+ interp_load_addr
>= exec_load_addr
)
649 /* We don't have the API to get the address of a simulator
650 memory area, so we go via a temporary area. Luckily, the
651 interpreter is supposed to be small, less than 0x40000
653 sim_do_commandf (sd
, "memory region 0x%lx,0x%lx",
654 interp_load_addr
, interpsiz
);
656 /* Now that memory for the interpreter is defined, load it. */
657 if (!cris_load_elf_file (sd
, ibfd
, cris_write_interp
))
660 /* It's no use setting STATE_START_ADDR, because it gets
661 overwritten by a sim_analyze_program call in sim_load. Let's
662 just store it locally. */
664 = (bfd_get_start_address (ibfd
)
665 - interp_bounds
.startmem
+ interp_load_addr
);
667 /* Linux cares only about the first PT_INTERP, so let's ignore
672 /* Register R10 should hold 0 at static start (no finifunc), but
673 that's the default, so don't bother. */
685 "%s: could not load ELF interpreter `%s' for program `%s'\n",
687 interp
== NULL
? "(what's-its-name)" : interp
,
688 bfd_get_filename (abfd
));
693 /* Create an instance of the simulator. */
696 sim_open (SIM_OPEN_KIND kind
, host_callback
*callback
, struct bfd
*abfd
,
702 USI endmem
= CRIS_DEFAULT_MEM_SIZE
;
705 SIM_DESC sd
= sim_state_alloc (kind
, callback
);
707 static const struct auxv_entries_s
710 USI (*efn
) (struct bfd
*ebfd
);
714 #define AUX_ENT(a, b) {a, NULL, b}
715 #define AUX_ENTF(a, f) {a, f, 0}
716 AUX_ENT (AT_HWCAP
, 0),
717 AUX_ENT (AT_PAGESZ
, 8192),
718 AUX_ENT (AT_CLKTCK
, 100),
719 AUX_ENTF (AT_PHDR
, aux_ent_phdr
),
720 AUX_ENTF (AT_PHENT
, aux_ent_phent
),
721 AUX_ENTF (AT_PHNUM
, aux_ent_phnum
),
722 AUX_ENTF (AT_BASE
, aux_ent_base
),
723 AUX_ENT (AT_FLAGS
, 0),
724 AUX_ENTF (AT_ENTRY
, aux_ent_entry
),
726 /* Or is root better? Maybe have it settable? */
727 AUX_ENT (AT_UID
, 500),
728 AUX_ENT (AT_EUID
, 500),
729 AUX_ENT (AT_GID
, 500),
730 AUX_ENT (AT_EGID
, 500),
731 AUX_ENT (AT_SECURE
, 0),
735 /* Can't initialize to "" below. It's either a GCC bug in old
736 releases (up to and including 2.95.3 (.4 in debian) or a bug in the
737 standard ;-) that the rest of the elements won't be initialized. */
738 bfd_byte sp_init
[4] = {0, 0, 0, 0};
740 /* The cpu data is kept in a separately allocated chunk of memory. */
741 if (sim_cpu_alloc_all (sd
, 1, cgen_cpu_max_extra_bytes ()) != SIM_RC_OK
)
747 if (sim_pre_argv_init (sd
, argv
[0]) != SIM_RC_OK
)
753 /* Add the CRIS-specific option list to the simulator. */
754 if (sim_add_option_table (sd
, NULL
, cris_options
) != SIM_RC_OK
)
760 /* getopt will print the error message so we just have to exit if this fails.
761 FIXME: Hmmm... in the case of gdb we need getopt to call
763 if (sim_parse_args (sd
, argv
) != SIM_RC_OK
)
769 /* If we have a binary program, endianness-setting would not be taken
770 from elsewhere unfortunately, so set it here. At the time of this
771 writing, it isn't used until sim_config, but that might change so
772 set it here before memory is defined or touched. */
773 current_target_byte_order
= LITTLE_ENDIAN
;
775 /* check for/establish the reference program image */
776 if (sim_analyze_program (sd
,
777 (STATE_PROG_ARGV (sd
) != NULL
778 ? *STATE_PROG_ARGV (sd
)
782 /* When there's an error, sim_analyze_program has already output
783 a message. Let's just clarify it, as "not an object file"
784 perhaps doesn't ring a bell. */
785 sim_io_eprintf (sd
, "(not a CRIS program)\n");
790 /* We might get called with the caller expecting us to get hold of
791 the bfd for ourselves, which would happen at the
792 sim_analyze_program call above. */
794 abfd
= STATE_PROG_BFD (sd
);
796 /* Adjust the addresses of the program at this point. Unfortunately
797 this does not affect ELF program headers, so we have to handle
799 cris_offset_sections (sd
, cris_program_offset
);
801 if (abfd
!= NULL
&& bfd_get_arch (abfd
) == bfd_arch_unknown
)
803 if (STATE_PROG_ARGV (sd
) != NULL
)
804 sim_io_eprintf (sd
, "%s: `%s' is not a CRIS program\n",
805 STATE_MY_NAME (sd
), *STATE_PROG_ARGV (sd
));
807 sim_io_eprintf (sd
, "%s: program to be run is not a CRIS program\n",
813 /* For CRIS simulator-specific use, we need to find out the bounds of
814 the program as well, which is not done by sim_analyze_program
818 struct progbounds pb
;
820 /* The sections should now be accessible using bfd functions. */
821 cris_get_progbounds (abfd
, &pb
);
823 /* We align the area that the program uses to page boundaries. */
824 startmem
= pb
.startmem
& ~8191;
826 endmem
= (endbrk
+ 8191) & ~8191;
829 /* Find out how much room is needed for the environment and argv, create
830 that memory and fill it. Only do this when there's a program
832 if (abfd
!= NULL
&& !cris_bare_iron
)
834 char *name
= bfd_get_filename (abfd
);
835 char **my_environ
= GET_ENVIRON ();
836 /* We use these maps to give the same behavior as the old xsim
838 USI envtop
= 0x40000000;
839 USI stacktop
= 0x3e000000;
842 int len
= strlen (name
) + 1;
846 char **prog_argv
= STATE_PROG_ARGV (sd
);
851 /* Count in the environment as well. */
852 for (envc
= 0; my_environ
[envc
] != NULL
; envc
++)
853 len
+= strlen (my_environ
[envc
]) + 1;
855 for (i
= 0; prog_argv
[i
] != NULL
; my_argc
++, i
++)
856 len
+= strlen (prog_argv
[i
]) + 1;
858 envstart
= (envtop
- len
) & ~8191;
860 /* Create read-only block for the environment strings. */
861 sim_core_attach (sd
, NULL
, 0, access_read
, 0,
862 envstart
, (len
+ 8191) & ~8191,
865 /* This shouldn't happen. */
866 if (envstart
< stacktop
)
867 stacktop
= envstart
- 64 * 8192;
871 /* Note that the linux kernel does not correctly compute the storage
872 needs for the static-exe AUX vector. */
874 csp
-= sizeof (auxv_entries
) / sizeof (auxv_entries
[0]) * 4 * 2;
876 csp
-= (envc
+ 1) * 4;
877 csp
-= (my_argc
+ 1) * 4;
880 /* Write the target representation of the start-up-value for the
881 stack-pointer suitable for register initialization below. */
882 bfd_putl32 (csp
, sp_init
);
884 /* If we make this 1M higher; say 8192*1024, we have to take
885 special precautions for pthreads, because pthreads assumes that
886 the memory that low isn't mmapped, and that it can mmap it
887 without fallback in case of failure (and we fail ungracefully
888 long before *that*: the memory isn't accounted for in our mmap
890 stack_low
= (csp
- (7168*1024)) & ~8191;
892 stacklen
= stacktop
- stack_low
;
894 /* Tee hee, we have an executable stack. Well, it's necessary to
895 test GCC trampolines... */
896 sim_core_attach (sd
, NULL
, 0, access_read_write_exec
, 0,
900 epp
= epp0
= envstart
;
902 /* Can't use sim_core_write_unaligned_4 without everything
903 initialized when tracing, and then these writes would get into
905 #define write_dword(addr, data) \
910 bfd_putl32 (data_, buf); \
911 if (sim_core_write_buffer (sd, NULL, NULL_CIA, buf, addr_, 4) != 4)\
916 write_dword (csp
, my_argc
);
919 for (i
= 0; i
< my_argc
; i
++, csp
+= 4)
921 size_t strln
= strlen (prog_argv
[i
]) + 1;
923 if (sim_core_write_buffer (sd
, NULL
, NULL_CIA
, prog_argv
[i
], epp
,
928 write_dword (csp
, envstart
+ epp
- epp0
);
932 write_dword (csp
, 0);
935 for (i
= 0; i
< envc
; i
++, csp
+= 4)
937 unsigned int strln
= strlen (my_environ
[i
]) + 1;
939 if (sim_core_write_buffer (sd
, NULL
, NULL_CIA
, my_environ
[i
], epp
,
944 write_dword (csp
, envstart
+ epp
- epp0
);
948 write_dword (csp
, 0);
951 /* The load address of the executable could presumably be
952 different than the lowest used memory address, but let's
953 stick to simplicity until needed. And
954 cris_handle_interpreter might change startmem and endmem, so
956 exec_load_addr
= startmem
;
958 if (!cris_handle_interpreter (sd
, abfd
))
961 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
962 for (i
= 0; i
< sizeof (auxv_entries
) / sizeof (auxv_entries
[0]); i
++)
964 write_dword (csp
, auxv_entries
[i
].id
);
965 write_dword (csp
+ 4,
966 auxv_entries
[i
].efn
!= NULL
967 ? (*auxv_entries
[i
].efn
) (abfd
)
968 : auxv_entries
[i
].val
);
973 /* Allocate core managed memory if none specified by user. */
974 if (sim_core_read_buffer (sd
, NULL
, read_map
, &c
, startmem
, 1) == 0)
975 sim_do_commandf (sd
, "memory region 0x%lx,0x%lx", startmem
,
978 /* Allocate simulator I/O managed memory if none specified by user. */
979 if (cris_have_900000xxif
)
980 sim_hw_parse (sd
, "/core/%s/reg %#x %i", "cris_900000xx", 0x90000000, 0x100);
982 /* Establish any remaining configuration options. */
983 if (sim_config (sd
) != SIM_RC_OK
)
990 if (sim_post_argv_init (sd
) != SIM_RC_OK
)
996 /* Open a copy of the cpu descriptor table. */
998 CGEN_CPU_DESC cd
= cris_cgen_cpu_open_1 (STATE_ARCHITECTURE (sd
)->printable_name
,
1000 for (i
= 0; i
< MAX_NR_PROCESSORS
; ++i
)
1002 SIM_CPU
*cpu
= STATE_CPU (sd
, i
);
1003 CPU_CPU_DESC (cpu
) = cd
;
1004 CPU_DISASSEMBLER (cpu
) = cris_disassemble_insn
;
1006 /* See cris_option_handler for the reason why this is needed. */
1007 CPU_CRIS_MISC_PROFILE (cpu
)->flags
= STATE_TRACE_FLAGS (sd
)[0];
1009 /* Set SP to the stack we allocated above. */
1010 (* CPU_REG_STORE (cpu
)) (cpu
, H_GR_SP
, (char *) sp_init
, 4);
1012 /* Set the simulator environment data. */
1013 cpu
->highest_mmapped_page
= NULL
;
1014 cpu
->endmem
= endmem
;
1015 cpu
->endbrk
= endbrk
;
1016 cpu
->stack_low
= stack_low
;
1020 cpu
->max_threadid
= 0;
1021 cpu
->thread_data
= NULL
;
1022 memset (cpu
->sighandler
, 0, sizeof (cpu
->sighandler
));
1023 cpu
->make_thread_cpu_data
= NULL
;
1024 cpu
->thread_cpu_data_size
= 0;
1026 cpu
->deliver_interrupt
= NULL
;
1030 /* Always be cycle-accurate and call before/after functions if
1032 sim_profile_set_option (sd
, "-model", PROFILE_MODEL_IDX
, "on");
1036 /* Initialize various cgen things not done by common framework.
1037 Must be done after cris_cgen_cpu_open. */
1040 /* Store in a global so things like cris_dump_regs can be invoked
1041 from the gdb command line. */
1044 cris_set_callbacks (callback
);
1050 sim_create_inferior (SIM_DESC sd
, struct bfd
*abfd
,
1051 char **argv ATTRIBUTE_UNUSED
,
1052 char **envp ATTRIBUTE_UNUSED
)
1054 SIM_CPU
*current_cpu
= STATE_CPU (sd
, 0);
1058 addr
= cris_start_address
!= (SIM_ADDR
) -1
1059 ? cris_start_address
1060 : (interp_start_addr
!= 0
1062 : bfd_get_start_address (abfd
));
1065 sim_pc_set (current_cpu
, addr
);
1067 /* Standalone mode (i.e. `run`) will take care of the argv for us in
1068 sim_open() -> sim_parse_args(). But in debug mode (i.e. 'target sim'
1069 with `gdb`), we need to handle it because the user can change the
1070 argv on the fly via gdb's 'run'. */
1071 if (STATE_PROG_ARGV (sd
) != argv
)
1073 freeargv (STATE_PROG_ARGV (sd
));
1074 STATE_PROG_ARGV (sd
) = dupargv (argv
);
1080 /* Disassemble an instruction. */
1083 cris_disassemble_insn (SIM_CPU
*cpu
,
1084 const CGEN_INSN
*insn ATTRIBUTE_UNUSED
,
1085 const ARGBUF
*abuf ATTRIBUTE_UNUSED
,
1086 IADDR pc
, char *buf
)
1088 disassembler_ftype pinsn
;
1089 struct disassemble_info disasm_info
;
1091 SIM_DESC sd
= CPU_STATE (cpu
);
1093 sfile
.buffer
= sfile
.current
= buf
;
1094 INIT_DISASSEMBLE_INFO (disasm_info
, (FILE *) &sfile
,
1095 (fprintf_ftype
) sim_disasm_sprintf
);
1096 disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1097 disasm_info
.read_memory_func
= sim_disasm_read_memory
;
1098 disasm_info
.memory_error_func
= sim_disasm_perror_memory
;
1099 disasm_info
.application_data
= (PTR
) cpu
;
1100 pinsn
= cris_get_disassembler (STATE_PROG_BFD (sd
));
1101 (*pinsn
) (pc
, &disasm_info
);