1 /* Main simulator entry points specific to the CRIS.
2 Copyright (C) 2004-2021 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"
31 #include "sim-options.h"
34 /* Apparently the autoconf bits are missing (though HAVE_ENVIRON is used
35 in other dirs; also lacking there). Patch around it for major systems. */
36 #if defined (HAVE_ENVIRON) || defined (__GLIBC__)
37 extern char **environ
;
38 #define GET_ENVIRON() environ
40 char *missing_environ
[] = { "SHELL=/bin/sh", "PATH=/bin:/usr/bin", NULL
};
41 #define GET_ENVIRON() missing_environ
44 /* Used with get_progbounds to find out how much memory is needed for the
45 program. We don't want to allocate more, since that could mask
46 invalid memory accesses program bugs. */
54 static void free_state (SIM_DESC
);
55 static void get_progbounds_iterator (bfd
*, asection
*, void *);
56 static SIM_RC
cris_option_handler (SIM_DESC
, sim_cpu
*, int, char *, int);
58 /* Since we don't build the cgen-opcode table, we use the old
60 static CGEN_DISASSEMBLER cris_disassemble_insn
;
62 /* By default, we set up stack and environment variables like the Linux
64 static char cris_bare_iron
= 0;
66 /* Whether 0x9000000xx have simulator-specific meanings. */
67 char cris_have_900000xxif
= 0;
69 /* Used to optionally override the default start address of the
71 static USI cris_start_address
= 0xffffffffu
;
73 /* Used to optionally add offsets to the loaded image and its start
74 address. (Not used for the interpreter of dynamically loaded
75 programs or the DSO:s.) */
76 static int cris_program_offset
= 0;
78 /* What to do when we face a more or less unknown syscall. */
79 enum cris_unknown_syscall_action_type cris_unknown_syscall_action
80 = CRIS_USYSC_MSG_STOP
;
82 /* CRIS-specific options. */
84 OPTION_CRIS_STATS
= OPTION_START
,
87 OPTION_CRIS_PROGRAM_OFFSET
,
88 OPTION_CRIS_STARTADDR
,
89 OPTION_CRIS_900000XXIF
,
90 OPTION_CRIS_UNKNOWN_SYSCALL
93 static const OPTION cris_options
[] =
95 { {"cris-cycles", required_argument
, NULL
, OPTION_CRIS_STATS
},
96 '\0', "basic|unaligned|schedulable|all",
97 "Dump execution statistics",
98 cris_option_handler
, NULL
},
99 { {"cris-trace", required_argument
, NULL
, OPTION_CRIS_TRACE
},
101 "Emit trace information while running",
102 cris_option_handler
, NULL
},
103 { {"cris-naked", no_argument
, NULL
, OPTION_CRIS_NAKED
},
104 '\0', NULL
, "Don't set up stack and environment",
105 cris_option_handler
, NULL
},
106 { {"cris-900000xx", no_argument
, NULL
, OPTION_CRIS_900000XXIF
},
107 '\0', NULL
, "Define addresses at 0x900000xx with simulator semantics",
108 cris_option_handler
, NULL
},
109 { {"cris-unknown-syscall", required_argument
, NULL
,
110 OPTION_CRIS_UNKNOWN_SYSCALL
},
111 '\0', "stop|enosys|enosys-quiet", "Action at an unknown system call",
112 cris_option_handler
, NULL
},
113 { {"cris-program-offset", required_argument
, NULL
,
114 OPTION_CRIS_PROGRAM_OFFSET
},
116 "Offset image addresses and default start address of a program",
117 cris_option_handler
},
118 { {"cris-start-address", required_argument
, NULL
, OPTION_CRIS_STARTADDR
},
119 '\0', "ADDRESS", "Set start address",
120 cris_option_handler
},
121 { {NULL
, no_argument
, NULL
, 0}, '\0', NULL
, NULL
, NULL
, NULL
}
124 /* Handle CRIS-specific options. */
127 cris_option_handler (SIM_DESC sd
, sim_cpu
*cpu ATTRIBUTE_UNUSED
, int opt
,
128 char *arg
, int is_command ATTRIBUTE_UNUSED
)
130 /* The options are CRIS-specific, but cpu-specific option-handling is
131 broken; required to being with "--cpu0-". We store the flags in an
132 unused field in the global state structure and move the flags over
133 to the module-specific CPU data when we store things in the
134 cpu-specific structure. */
135 char *tracefp
= STATE_TRACE_FLAGS (sd
);
138 switch ((CRIS_OPTIONS
) opt
)
140 case OPTION_CRIS_STATS
:
141 if (strcmp (arg
, "basic") == 0)
142 *tracefp
= FLAG_CRIS_MISC_PROFILE_SIMPLE
;
143 else if (strcmp (arg
, "unaligned") == 0)
145 = (FLAG_CRIS_MISC_PROFILE_UNALIGNED
146 | FLAG_CRIS_MISC_PROFILE_SIMPLE
);
147 else if (strcmp (arg
, "schedulable") == 0)
149 = (FLAG_CRIS_MISC_PROFILE_SCHEDULABLE
150 | FLAG_CRIS_MISC_PROFILE_SIMPLE
);
151 else if (strcmp (arg
, "all") == 0)
152 *tracefp
= FLAG_CRIS_MISC_PROFILE_ALL
;
155 /* Beware; the framework does not handle the error case;
156 we have to do it ourselves. */
157 sim_io_eprintf (sd
, "Unknown option `--cris-cycles=%s'\n", arg
);
162 case OPTION_CRIS_TRACE
:
163 if (strcmp (arg
, "basic") == 0)
164 *tracefp
|= FLAG_CRIS_MISC_PROFILE_XSIM_TRACE
;
167 sim_io_eprintf (sd
, "Unknown option `--cris-trace=%s'\n", arg
);
172 case OPTION_CRIS_NAKED
:
176 case OPTION_CRIS_900000XXIF
:
177 cris_have_900000xxif
= 1;
180 case OPTION_CRIS_STARTADDR
:
182 cris_start_address
= (USI
) strtoul (chp
, &chp
, 0);
184 if (errno
!= 0 || *chp
!= 0)
186 sim_io_eprintf (sd
, "Invalid option `--cris-start-address=%s'\n",
192 case OPTION_CRIS_PROGRAM_OFFSET
:
194 cris_program_offset
= (int) strtol (chp
, &chp
, 0);
196 if (errno
!= 0 || *chp
!= 0)
198 sim_io_eprintf (sd
, "Invalid option `--cris-program-offset=%s'\n",
204 case OPTION_CRIS_UNKNOWN_SYSCALL
:
205 if (strcmp (arg
, "enosys") == 0)
206 cris_unknown_syscall_action
= CRIS_USYSC_MSG_ENOSYS
;
207 else if (strcmp (arg
, "enosys-quiet") == 0)
208 cris_unknown_syscall_action
= CRIS_USYSC_QUIET_ENOSYS
;
209 else if (strcmp (arg
, "stop") == 0)
210 cris_unknown_syscall_action
= CRIS_USYSC_MSG_STOP
;
213 sim_io_eprintf (sd
, "Unknown option `--cris-unknown-syscall=%s'\n",
220 /* We'll actually never get here; the caller handles the error
222 sim_io_eprintf (sd
, "Unknown option `%s'\n", arg
);
226 /* Imply --profile-model=on. */
227 return sim_profile_set_option (sd
, "-model", PROFILE_MODEL_IDX
, "on");
230 /* An ELF-specific simplified ../common/sim-load.c:sim_load_file,
231 using the program headers, not sections, in order to make sure that
232 the program headers themeselves are also loaded. The caller is
233 responsible for asserting that ABFD is an ELF file. */
236 cris_load_elf_file (SIM_DESC sd
, struct bfd
*abfd
, sim_write_fn do_write
)
238 Elf_Internal_Phdr
*phdr
;
241 bfd_boolean verbose
= STATE_OPEN_KIND (sd
) == SIM_OPEN_DEBUG
;
243 phdr
= elf_tdata (abfd
)->phdr
;
244 n_hdrs
= elf_elfheader (abfd
)->e_phnum
;
246 /* We're only interested in PT_LOAD; all necessary information
247 should be covered by that. */
248 for (i
= 0; i
< n_hdrs
; i
++)
251 bfd_vma lma
= STATE_LOAD_AT_LMA_P (sd
)
252 ? phdr
[i
].p_paddr
: phdr
[i
].p_vaddr
;
254 if (phdr
[i
].p_type
!= PT_LOAD
)
257 buf
= xmalloc (phdr
[i
].p_filesz
);
261 "Loading segment at 0x%" BFD_VMA_FMT
"x, size 0x%lx\n",
262 lma
, phdr
[i
].p_filesz
);
264 if (bfd_seek (abfd
, phdr
[i
].p_offset
, SEEK_SET
) != 0
265 || (bfd_bread (buf
, phdr
[i
].p_filesz
, abfd
) != phdr
[i
].p_filesz
))
268 "%s: could not read segment at 0x%" BFD_VMA_FMT
"x, "
270 STATE_MY_NAME (sd
), lma
, phdr
[i
].p_filesz
);
275 if (do_write (sd
, lma
, buf
, phdr
[i
].p_filesz
) != phdr
[i
].p_filesz
)
278 "%s: could not load segment at 0x%" BFD_VMA_FMT
"x, "
280 STATE_MY_NAME (sd
), lma
, phdr
[i
].p_filesz
);
291 /* Cover function of sim_state_free to free the cpu buffers as well. */
294 free_state (SIM_DESC sd
)
296 if (STATE_MODULES (sd
) != NULL
)
297 sim_module_uninstall (sd
);
298 sim_cpu_free_all (sd
);
302 /* Helper struct for cris_set_section_offset_iterator. */
310 /* BFD section iterator to offset the LMA and VMA. */
313 cris_set_section_offset_iterator (bfd
*abfd
, asection
*s
, void *vp
)
315 struct offsetinfo
*p
= (struct offsetinfo
*) vp
;
317 int offset
= p
->offset
;
319 if ((bfd_section_flags (s
) & SEC_ALLOC
))
321 bfd_vma vma
= bfd_section_vma (s
);
323 bfd_set_section_vma (s
, vma
+ offset
);
326 /* This seems clumsy and inaccurate, but let's stick to doing it the
327 same way as sim_analyze_program for consistency. */
328 if (strcmp (bfd_section_name (s
), ".text") == 0)
329 STATE_TEXT_START (sd
) = bfd_section_vma (s
);
332 /* Adjust the start-address, LMA and VMA of a SD. Must be called
333 after sim_analyze_program. */
336 cris_offset_sections (SIM_DESC sd
, int offset
)
339 struct bfd
*abfd
= STATE_PROG_BFD (sd
);
341 struct offsetinfo oi
;
343 /* Only happens for usage error. */
350 bfd_map_over_sections (abfd
, cris_set_section_offset_iterator
, &oi
);
351 ret
= bfd_set_start_address (abfd
, bfd_get_start_address (abfd
) + offset
);
353 STATE_START_ADDR (sd
) = bfd_get_start_address (abfd
);
356 /* BFD section iterator to find the highest and lowest allocated and
357 non-allocated section addresses (plus one). */
360 get_progbounds_iterator (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*s
, void *vp
)
362 struct progbounds
*pbp
= (struct progbounds
*) vp
;
364 if ((bfd_section_flags (s
) & SEC_ALLOC
))
366 bfd_size_type sec_size
= bfd_section_size (s
);
367 bfd_size_type sec_start
= bfd_section_vma (s
);
368 bfd_size_type sec_end
= sec_start
+ sec_size
;
370 if (sec_end
> pbp
->endmem
)
371 pbp
->endmem
= sec_end
;
373 if (sec_start
< pbp
->startmem
)
374 pbp
->startmem
= sec_start
;
376 if ((bfd_section_flags (s
) & SEC_LOAD
))
378 if (sec_end
> pbp
->end_loadmem
)
379 pbp
->end_loadmem
= sec_end
;
381 else if (sec_start
< pbp
->start_nonloadmem
)
382 pbp
->start_nonloadmem
= sec_start
;
386 /* Get the program boundaries. Because not everything is covered by
387 sections in ELF, notably the program headers, we use the program
391 cris_get_progbounds (struct bfd
*abfd
, struct progbounds
*pbp
)
393 Elf_Internal_Phdr
*phdr
;
397 pbp
->startmem
= 0xffffffff;
399 pbp
->end_loadmem
= 0;
400 pbp
->start_nonloadmem
= 0xffffffff;
402 /* In case we're ever used for something other than ELF, use the
404 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
406 bfd_map_over_sections (abfd
, get_progbounds_iterator
, pbp
);
410 phdr
= elf_tdata (abfd
)->phdr
;
411 n_hdrs
= elf_elfheader (abfd
)->e_phnum
;
413 /* We're only interested in PT_LOAD; all necessary information
414 should be covered by that. */
415 for (i
= 0; i
< n_hdrs
; i
++)
417 if (phdr
[i
].p_type
!= PT_LOAD
)
420 if (phdr
[i
].p_paddr
< pbp
->startmem
)
421 pbp
->startmem
= phdr
[i
].p_paddr
;
423 if (phdr
[i
].p_paddr
+ phdr
[i
].p_memsz
> pbp
->endmem
)
424 pbp
->endmem
= phdr
[i
].p_paddr
+ phdr
[i
].p_memsz
;
426 if (phdr
[i
].p_paddr
+ phdr
[i
].p_filesz
> pbp
->end_loadmem
)
427 pbp
->end_loadmem
= phdr
[i
].p_paddr
+ phdr
[i
].p_filesz
;
429 if (phdr
[i
].p_memsz
> phdr
[i
].p_filesz
430 && phdr
[i
].p_paddr
+ phdr
[i
].p_filesz
< pbp
->start_nonloadmem
)
431 pbp
->start_nonloadmem
= phdr
[i
].p_paddr
+ phdr
[i
].p_filesz
;
435 /* Parameter communication by static variables, hmm... Oh well, for
437 static bfd_vma exec_load_addr
;
438 static bfd_vma interp_load_addr
;
439 static bfd_vma interp_start_addr
;
441 /* Supposed to mimic Linux' "NEW_AUX_ENT (AT_PHDR, load_addr + exec->e_phoff)". */
444 aux_ent_phdr (struct bfd
*ebfd
)
446 return elf_elfheader (ebfd
)->e_phoff
+ exec_load_addr
;
449 /* We just pass on the header info; we don't have our own idea of the
450 program header entry size. */
453 aux_ent_phent (struct bfd
*ebfd
)
455 return elf_elfheader (ebfd
)->e_phentsize
;
458 /* Like "NEW_AUX_ENT(AT_PHNUM, exec->e_phnum)". */
461 aux_ent_phnum (struct bfd
*ebfd
)
463 return elf_elfheader (ebfd
)->e_phnum
;
466 /* Like "NEW_AUX_ENT(AT_BASE, interp_load_addr)". */
469 aux_ent_base (struct bfd
*ebfd
)
471 return interp_load_addr
;
474 /* Like "NEW_AUX_ENT(AT_ENTRY, exec->e_entry)". */
477 aux_ent_entry (struct bfd
*ebfd
)
479 ASSERT (elf_elfheader (ebfd
)->e_entry
== bfd_get_start_address (ebfd
));
480 return elf_elfheader (ebfd
)->e_entry
;
483 /* Helper for cris_handle_interpreter: like sim_write, but load at
484 interp_load_addr offset. */
487 cris_write_interp (SIM_DESC sd
, SIM_ADDR mem
, unsigned char *buf
, int length
)
489 return sim_write (sd
, mem
+ interp_load_addr
, buf
, length
);
492 /* Cater to the presence of an interpreter: load it and set
493 interp_start_addr. Return FALSE if there was an error, TRUE if
494 everything went fine, including an interpreter being absent and
495 the program being in a non-ELF format. */
498 cris_handle_interpreter (SIM_DESC sd
, struct bfd
*abfd
)
504 bfd_boolean ok
= FALSE
;
505 Elf_Internal_Phdr
*phdr
;
507 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
510 phdr
= elf_tdata (abfd
)->phdr
;
511 n_hdrs
= aux_ent_phnum (abfd
);
513 /* Check the program headers for presence of an interpreter. */
514 for (i
= 0; i
< n_hdrs
; i
++)
517 bfd_size_type interpsiz
, interp_filesiz
;
518 struct progbounds interp_bounds
;
520 if (phdr
[i
].p_type
!= PT_INTERP
)
523 /* Get the name of the interpreter, prepended with the sysroot
524 (empty if absent). */
525 interplen
= phdr
[i
].p_filesz
;
526 interp
= xmalloc (interplen
+ strlen (simulator_sysroot
));
527 strcpy (interp
, simulator_sysroot
);
529 /* Read in the name. */
530 if (bfd_seek (abfd
, phdr
[i
].p_offset
, SEEK_SET
) != 0
531 || (bfd_bread (interp
+ strlen (simulator_sysroot
), interplen
, abfd
)
533 goto interpname_failed
;
535 /* Like Linux, require the string to be 0-terminated. */
536 if (interp
[interplen
+ strlen (simulator_sysroot
) - 1] != 0)
537 goto interpname_failed
;
539 /* Inspect the interpreter. */
540 ibfd
= bfd_openr (interp
, STATE_TARGET (sd
));
542 goto interpname_failed
;
544 /* The interpreter is at least something readable to BFD; make
545 sure it's an ELF non-archive file. */
546 if (!bfd_check_format (ibfd
, bfd_object
)
547 || bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
550 /* Check the layout of the interpreter. */
551 cris_get_progbounds (ibfd
, &interp_bounds
);
553 /* Round down to pagesize the start page and up the endpage.
554 Don't round the *load and *nonload members. */
555 interp_bounds
.startmem
&= ~8191;
556 interp_bounds
.endmem
= (interp_bounds
.endmem
+ 8191) & ~8191;
558 /* Until we need a more dynamic solution, assume we can put the
559 interpreter at this fixed location. NB: this is not what
560 happens for Linux 2008-12-28, but it could and might and
562 interp_load_addr
= 0x40000;
563 interpsiz
= interp_bounds
.endmem
- interp_bounds
.startmem
;
564 interp_filesiz
= interp_bounds
.end_loadmem
- interp_bounds
.startmem
;
566 /* If we have a non-DSO or interpreter starting at the wrong
568 if (interp_bounds
.startmem
!= 0
569 || interpsiz
+ interp_load_addr
>= exec_load_addr
)
572 /* We don't have the API to get the address of a simulator
573 memory area, so we go via a temporary area. Luckily, the
574 interpreter is supposed to be small, less than 0x40000
576 sim_do_commandf (sd
, "memory region 0x%" BFD_VMA_FMT
"x,0x%lx",
577 interp_load_addr
, interpsiz
);
579 /* Now that memory for the interpreter is defined, load it. */
580 if (!cris_load_elf_file (sd
, ibfd
, cris_write_interp
))
583 /* It's no use setting STATE_START_ADDR, because it gets
584 overwritten by a sim_analyze_program call in sim_load. Let's
585 just store it locally. */
587 = (bfd_get_start_address (ibfd
)
588 - interp_bounds
.startmem
+ interp_load_addr
);
590 /* Linux cares only about the first PT_INTERP, so let's ignore
595 /* Register R10 should hold 0 at static start (no finifunc), but
596 that's the default, so don't bother. */
608 "%s: could not load ELF interpreter `%s' for program `%s'\n",
610 interp
== NULL
? "(what's-its-name)" : interp
,
611 bfd_get_filename (abfd
));
616 /* Create an instance of the simulator. */
619 sim_open (SIM_OPEN_KIND kind
, host_callback
*callback
, struct bfd
*abfd
,
625 USI endmem
= CRIS_DEFAULT_MEM_SIZE
;
628 SIM_DESC sd
= sim_state_alloc (kind
, callback
);
630 static const struct auxv_entries_s
633 USI (*efn
) (struct bfd
*ebfd
);
637 #define AUX_ENT(a, b) {a, NULL, b}
638 #define AUX_ENTF(a, f) {a, f, 0}
639 AUX_ENT (AT_HWCAP
, 0),
640 AUX_ENT (AT_PAGESZ
, 8192),
641 AUX_ENT (AT_CLKTCK
, 100),
642 AUX_ENTF (AT_PHDR
, aux_ent_phdr
),
643 AUX_ENTF (AT_PHENT
, aux_ent_phent
),
644 AUX_ENTF (AT_PHNUM
, aux_ent_phnum
),
645 AUX_ENTF (AT_BASE
, aux_ent_base
),
646 AUX_ENT (AT_FLAGS
, 0),
647 AUX_ENTF (AT_ENTRY
, aux_ent_entry
),
649 /* Or is root better? Maybe have it settable? */
650 AUX_ENT (AT_UID
, 500),
651 AUX_ENT (AT_EUID
, 500),
652 AUX_ENT (AT_GID
, 500),
653 AUX_ENT (AT_EGID
, 500),
654 AUX_ENT (AT_SECURE
, 0),
658 /* Can't initialize to "" below. It's either a GCC bug in old
659 releases (up to and including 2.95.3 (.4 in debian) or a bug in the
660 standard ;-) that the rest of the elements won't be initialized. */
661 bfd_byte sp_init
[4] = {0, 0, 0, 0};
663 /* The cpu data is kept in a separately allocated chunk of memory. */
664 if (sim_cpu_alloc_all (sd
, 1) != SIM_RC_OK
)
670 if (sim_pre_argv_init (sd
, argv
[0]) != SIM_RC_OK
)
676 /* Add the CRIS-specific option list to the simulator. */
677 if (sim_add_option_table (sd
, NULL
, cris_options
) != SIM_RC_OK
)
683 /* The parser will print an error message for us, so we silently return. */
684 if (sim_parse_args (sd
, argv
) != SIM_RC_OK
)
690 /* check for/establish the reference program image */
691 if (sim_analyze_program (sd
,
692 (STATE_PROG_ARGV (sd
) != NULL
693 ? *STATE_PROG_ARGV (sd
)
697 /* When there's an error, sim_analyze_program has already output
698 a message. Let's just clarify it, as "not an object file"
699 perhaps doesn't ring a bell. */
700 sim_io_eprintf (sd
, "(not a CRIS program)\n");
705 /* We might get called with the caller expecting us to get hold of
706 the bfd for ourselves, which would happen at the
707 sim_analyze_program call above. */
709 abfd
= STATE_PROG_BFD (sd
);
711 /* Adjust the addresses of the program at this point. Unfortunately
712 this does not affect ELF program headers, so we have to handle
714 cris_offset_sections (sd
, cris_program_offset
);
716 if (abfd
!= NULL
&& bfd_get_arch (abfd
) == bfd_arch_unknown
)
718 if (STATE_PROG_ARGV (sd
) != NULL
)
719 sim_io_eprintf (sd
, "%s: `%s' is not a CRIS program\n",
720 STATE_MY_NAME (sd
), *STATE_PROG_ARGV (sd
));
722 sim_io_eprintf (sd
, "%s: program to be run is not a CRIS program\n",
728 /* For CRIS simulator-specific use, we need to find out the bounds of
729 the program as well, which is not done by sim_analyze_program
733 struct progbounds pb
;
735 /* The sections should now be accessible using bfd functions. */
736 cris_get_progbounds (abfd
, &pb
);
738 /* We align the area that the program uses to page boundaries. */
739 startmem
= pb
.startmem
& ~8191;
741 endmem
= (endbrk
+ 8191) & ~8191;
744 /* Find out how much room is needed for the environment and argv, create
745 that memory and fill it. Only do this when there's a program
747 if (abfd
!= NULL
&& !cris_bare_iron
)
749 const char *name
= bfd_get_filename (abfd
);
750 char **my_environ
= GET_ENVIRON ();
751 /* We use these maps to give the same behavior as the old xsim
753 USI envtop
= 0x40000000;
754 USI stacktop
= 0x3e000000;
757 int len
= strlen (name
) + 1;
761 char **prog_argv
= STATE_PROG_ARGV (sd
);
766 /* Count in the environment as well. */
767 for (envc
= 0; my_environ
[envc
] != NULL
; envc
++)
768 len
+= strlen (my_environ
[envc
]) + 1;
770 for (i
= 0; prog_argv
[i
] != NULL
; my_argc
++, i
++)
771 len
+= strlen (prog_argv
[i
]) + 1;
773 envstart
= (envtop
- len
) & ~8191;
775 /* Create read-only block for the environment strings. */
776 sim_core_attach (sd
, NULL
, 0, access_read
, 0,
777 envstart
, (len
+ 8191) & ~8191,
780 /* This shouldn't happen. */
781 if (envstart
< stacktop
)
782 stacktop
= envstart
- 64 * 8192;
786 /* Note that the linux kernel does not correctly compute the storage
787 needs for the static-exe AUX vector. */
789 csp
-= ARRAY_SIZE (auxv_entries
) * 4 * 2;
791 csp
-= (envc
+ 1) * 4;
792 csp
-= (my_argc
+ 1) * 4;
795 /* Write the target representation of the start-up-value for the
796 stack-pointer suitable for register initialization below. */
797 bfd_putl32 (csp
, sp_init
);
799 /* If we make this 1M higher; say 8192*1024, we have to take
800 special precautions for pthreads, because pthreads assumes that
801 the memory that low isn't mmapped, and that it can mmap it
802 without fallback in case of failure (and we fail ungracefully
803 long before *that*: the memory isn't accounted for in our mmap
805 stack_low
= (csp
- (7168*1024)) & ~8191;
807 stacklen
= stacktop
- stack_low
;
809 /* Tee hee, we have an executable stack. Well, it's necessary to
810 test GCC trampolines... */
811 sim_core_attach (sd
, NULL
, 0, access_read_write_exec
, 0,
815 epp
= epp0
= envstart
;
817 /* Can't use sim_core_write_unaligned_4 without everything
818 initialized when tracing, and then these writes would get into
820 #define write_dword(addr, data) \
825 bfd_putl32 (data_, buf); \
826 if (sim_core_write_buffer (sd, NULL, NULL_CIA, buf, addr_, 4) != 4)\
831 write_dword (csp
, my_argc
);
834 for (i
= 0; i
< my_argc
; i
++, csp
+= 4)
836 size_t strln
= strlen (prog_argv
[i
]) + 1;
838 if (sim_core_write_buffer (sd
, NULL
, NULL_CIA
, prog_argv
[i
], epp
,
843 write_dword (csp
, envstart
+ epp
- epp0
);
847 write_dword (csp
, 0);
850 for (i
= 0; i
< envc
; i
++, csp
+= 4)
852 unsigned int strln
= strlen (my_environ
[i
]) + 1;
854 if (sim_core_write_buffer (sd
, NULL
, NULL_CIA
, my_environ
[i
], epp
,
859 write_dword (csp
, envstart
+ epp
- epp0
);
863 write_dword (csp
, 0);
866 /* The load address of the executable could presumably be
867 different than the lowest used memory address, but let's
868 stick to simplicity until needed. And
869 cris_handle_interpreter might change startmem and endmem, so
871 exec_load_addr
= startmem
;
873 if (!cris_handle_interpreter (sd
, abfd
))
876 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
877 for (i
= 0; i
< ARRAY_SIZE (auxv_entries
); i
++)
879 write_dword (csp
, auxv_entries
[i
].id
);
880 write_dword (csp
+ 4,
881 auxv_entries
[i
].efn
!= NULL
882 ? (*auxv_entries
[i
].efn
) (abfd
)
883 : auxv_entries
[i
].val
);
888 /* Allocate core managed memory if none specified by user. */
889 if (sim_core_read_buffer (sd
, NULL
, read_map
, &c
, startmem
, 1) == 0)
890 sim_do_commandf (sd
, "memory region 0x%" PRIx32
"x,0x%" PRIu32
"x",
891 startmem
, endmem
- startmem
);
893 /* Allocate simulator I/O managed memory if none specified by user. */
894 if (cris_have_900000xxif
)
895 sim_hw_parse (sd
, "/core/%s/reg %#x %i", "cris_900000xx", 0x90000000, 0x100);
897 /* Establish any remaining configuration options. */
898 if (sim_config (sd
) != SIM_RC_OK
)
905 if (sim_post_argv_init (sd
) != SIM_RC_OK
)
911 /* Open a copy of the cpu descriptor table. */
913 CGEN_CPU_DESC cd
= cris_cgen_cpu_open_1 (STATE_ARCHITECTURE (sd
)->printable_name
,
915 for (i
= 0; i
< MAX_NR_PROCESSORS
; ++i
)
917 SIM_CPU
*cpu
= STATE_CPU (sd
, i
);
918 CPU_CPU_DESC (cpu
) = cd
;
919 CPU_DISASSEMBLER (cpu
) = cris_disassemble_insn
;
921 /* See cris_option_handler for the reason why this is needed. */
922 CPU_CRIS_MISC_PROFILE (cpu
)->flags
= STATE_TRACE_FLAGS (sd
)[0];
924 /* Set SP to the stack we allocated above. */
925 (* CPU_REG_STORE (cpu
)) (cpu
, H_GR_SP
, (char *) sp_init
, 4);
927 /* Set the simulator environment data. */
928 cpu
->highest_mmapped_page
= NULL
;
929 cpu
->endmem
= endmem
;
930 cpu
->endbrk
= endbrk
;
931 cpu
->stack_low
= stack_low
;
935 cpu
->max_threadid
= 0;
936 cpu
->thread_data
= NULL
;
937 memset (cpu
->sighandler
, 0, sizeof (cpu
->sighandler
));
938 cpu
->make_thread_cpu_data
= NULL
;
939 cpu
->thread_cpu_data_size
= 0;
941 cpu
->deliver_interrupt
= NULL
;
945 /* Always be cycle-accurate and call before/after functions if
947 sim_profile_set_option (sd
, "-model", PROFILE_MODEL_IDX
, "on");
951 /* Initialize various cgen things not done by common framework.
952 Must be done after cris_cgen_cpu_open. */
955 cris_set_callbacks (callback
);
961 sim_create_inferior (SIM_DESC sd
, struct bfd
*abfd
,
962 char * const *argv ATTRIBUTE_UNUSED
,
963 char * const *envp ATTRIBUTE_UNUSED
)
965 SIM_CPU
*current_cpu
= STATE_CPU (sd
, 0);
969 addr
= cris_start_address
!= (SIM_ADDR
) -1
971 : (interp_start_addr
!= 0
973 : bfd_get_start_address (abfd
));
976 sim_pc_set (current_cpu
, addr
);
978 /* Standalone mode (i.e. `run`) will take care of the argv for us in
979 sim_open() -> sim_parse_args(). But in debug mode (i.e. 'target sim'
980 with `gdb`), we need to handle it because the user can change the
981 argv on the fly via gdb's 'run'. */
982 if (STATE_PROG_ARGV (sd
) != argv
)
984 freeargv (STATE_PROG_ARGV (sd
));
985 STATE_PROG_ARGV (sd
) = dupargv (argv
);
991 /* Disassemble an instruction. */
994 cris_disassemble_insn (SIM_CPU
*cpu
,
995 const CGEN_INSN
*insn ATTRIBUTE_UNUSED
,
996 const ARGBUF
*abuf ATTRIBUTE_UNUSED
,
999 disassembler_ftype pinsn
;
1000 struct disassemble_info disasm_info
;
1002 SIM_DESC sd
= CPU_STATE (cpu
);
1004 sfile
.buffer
= sfile
.current
= buf
;
1005 INIT_DISASSEMBLE_INFO (disasm_info
, (FILE *) &sfile
,
1006 (fprintf_ftype
) sim_disasm_sprintf
);
1007 disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1008 disasm_info
.read_memory_func
= sim_disasm_read_memory
;
1009 disasm_info
.memory_error_func
= sim_disasm_perror_memory
;
1010 disasm_info
.application_data
= (PTR
) cpu
;
1011 pinsn
= cris_get_disassembler (STATE_PROG_BFD (sd
));
1012 (*pinsn
) (pc
, &disasm_info
);