1 /* Main simulator entry points specific to the CRIS.
2 Copyright (C) 2004-2022 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
23 /* This must come before any other includes. */
26 #include "libiberty.h"
34 #include "sim-options.h"
39 /* Used with get_progbounds to find out how much memory is needed for the
40 program. We don't want to allocate more, since that could mask
41 invalid memory accesses program bugs. */
49 static void free_state (SIM_DESC
);
50 static void get_progbounds_iterator (bfd
*, asection
*, void *);
51 static SIM_RC
cris_option_handler (SIM_DESC
, sim_cpu
*, int, char *, int);
53 /* Since we don't build the cgen-opcode table, we use the old
55 static CGEN_DISASSEMBLER cris_disassemble_insn
;
57 /* By default, we set up stack and environment variables like the Linux
59 static char cris_bare_iron
= 0;
61 /* Whether 0x9000000xx have simulator-specific meanings. */
62 char cris_have_900000xxif
= 0;
64 /* Used to optionally override the default start address of the
66 static USI cris_start_address
= 0xffffffffu
;
68 /* Used to optionally add offsets to the loaded image and its start
69 address. (Not used for the interpreter of dynamically loaded
70 programs or the DSO:s.) */
71 static int cris_program_offset
= 0;
73 /* What to do when we face a more or less unknown syscall. */
74 enum cris_unknown_syscall_action_type cris_unknown_syscall_action
75 = CRIS_USYSC_MSG_STOP
;
77 /* CRIS-specific options. */
79 OPTION_CRIS_STATS
= OPTION_START
,
82 OPTION_CRIS_PROGRAM_OFFSET
,
83 OPTION_CRIS_STARTADDR
,
84 OPTION_CRIS_900000XXIF
,
85 OPTION_CRIS_UNKNOWN_SYSCALL
88 static const OPTION cris_options
[] =
90 { {"cris-cycles", required_argument
, NULL
, OPTION_CRIS_STATS
},
91 '\0', "basic|unaligned|schedulable|all",
92 "Dump execution statistics",
93 cris_option_handler
, NULL
},
94 { {"cris-trace", required_argument
, NULL
, OPTION_CRIS_TRACE
},
96 "Emit trace information while running",
97 cris_option_handler
, NULL
},
98 { {"cris-naked", no_argument
, NULL
, OPTION_CRIS_NAKED
},
99 '\0', NULL
, "Don't set up stack and environment",
100 cris_option_handler
, NULL
},
101 { {"cris-900000xx", no_argument
, NULL
, OPTION_CRIS_900000XXIF
},
102 '\0', NULL
, "Define addresses at 0x900000xx with simulator semantics",
103 cris_option_handler
, NULL
},
104 { {"cris-unknown-syscall", required_argument
, NULL
,
105 OPTION_CRIS_UNKNOWN_SYSCALL
},
106 '\0', "stop|enosys|enosys-quiet", "Action at an unknown system call",
107 cris_option_handler
, NULL
},
108 { {"cris-program-offset", required_argument
, NULL
,
109 OPTION_CRIS_PROGRAM_OFFSET
},
111 "Offset image addresses and default start address of a program",
112 cris_option_handler
},
113 { {"cris-start-address", required_argument
, NULL
, OPTION_CRIS_STARTADDR
},
114 '\0', "ADDRESS", "Set start address",
115 cris_option_handler
},
116 { {NULL
, no_argument
, NULL
, 0}, '\0', NULL
, NULL
, NULL
, NULL
}
119 /* Handle CRIS-specific options. */
122 cris_option_handler (SIM_DESC sd
, sim_cpu
*cpu ATTRIBUTE_UNUSED
, int opt
,
123 char *arg
, int is_command ATTRIBUTE_UNUSED
)
125 /* The options are CRIS-specific, but cpu-specific option-handling is
126 broken; required to being with "--cpu0-". We store the flags in an
127 unused field in the global state structure and move the flags over
128 to the module-specific CPU data when we store things in the
129 cpu-specific structure. */
130 char *tracefp
= STATE_TRACE_FLAGS (sd
);
133 switch ((CRIS_OPTIONS
) opt
)
135 case OPTION_CRIS_STATS
:
136 if (strcmp (arg
, "basic") == 0)
137 *tracefp
= FLAG_CRIS_MISC_PROFILE_SIMPLE
;
138 else if (strcmp (arg
, "unaligned") == 0)
140 = (FLAG_CRIS_MISC_PROFILE_UNALIGNED
141 | FLAG_CRIS_MISC_PROFILE_SIMPLE
);
142 else if (strcmp (arg
, "schedulable") == 0)
144 = (FLAG_CRIS_MISC_PROFILE_SCHEDULABLE
145 | FLAG_CRIS_MISC_PROFILE_SIMPLE
);
146 else if (strcmp (arg
, "all") == 0)
147 *tracefp
= FLAG_CRIS_MISC_PROFILE_ALL
;
150 /* Beware; the framework does not handle the error case;
151 we have to do it ourselves. */
152 sim_io_eprintf (sd
, "Unknown option `--cris-cycles=%s'\n", arg
);
157 case OPTION_CRIS_TRACE
:
158 if (strcmp (arg
, "basic") == 0)
159 *tracefp
|= FLAG_CRIS_MISC_PROFILE_XSIM_TRACE
;
162 sim_io_eprintf (sd
, "Unknown option `--cris-trace=%s'\n", arg
);
167 case OPTION_CRIS_NAKED
:
171 case OPTION_CRIS_900000XXIF
:
172 cris_have_900000xxif
= 1;
175 case OPTION_CRIS_STARTADDR
:
177 cris_start_address
= (USI
) strtoul (chp
, &chp
, 0);
179 if (errno
!= 0 || *chp
!= 0)
181 sim_io_eprintf (sd
, "Invalid option `--cris-start-address=%s'\n",
187 case OPTION_CRIS_PROGRAM_OFFSET
:
189 cris_program_offset
= (int) strtol (chp
, &chp
, 0);
191 if (errno
!= 0 || *chp
!= 0)
193 sim_io_eprintf (sd
, "Invalid option `--cris-program-offset=%s'\n",
199 case OPTION_CRIS_UNKNOWN_SYSCALL
:
200 if (strcmp (arg
, "enosys") == 0)
201 cris_unknown_syscall_action
= CRIS_USYSC_MSG_ENOSYS
;
202 else if (strcmp (arg
, "enosys-quiet") == 0)
203 cris_unknown_syscall_action
= CRIS_USYSC_QUIET_ENOSYS
;
204 else if (strcmp (arg
, "stop") == 0)
205 cris_unknown_syscall_action
= CRIS_USYSC_MSG_STOP
;
208 sim_io_eprintf (sd
, "Unknown option `--cris-unknown-syscall=%s'\n",
215 /* We'll actually never get here; the caller handles the error
217 sim_io_eprintf (sd
, "Unknown option `%s'\n", arg
);
221 /* Imply --profile-model=on. */
222 return sim_profile_set_option (sd
, "-model", PROFILE_MODEL_IDX
, "on");
225 /* An ELF-specific simplified ../common/sim-load.c:sim_load_file,
226 using the program headers, not sections, in order to make sure that
227 the program headers themeselves are also loaded. The caller is
228 responsible for asserting that ABFD is an ELF file. */
231 cris_load_elf_file (SIM_DESC sd
, struct bfd
*abfd
, sim_write_fn do_write
)
233 Elf_Internal_Phdr
*phdr
;
236 bfd_boolean verbose
= STATE_OPEN_KIND (sd
) == SIM_OPEN_DEBUG
;
238 phdr
= elf_tdata (abfd
)->phdr
;
239 n_hdrs
= elf_elfheader (abfd
)->e_phnum
;
241 /* We're only interested in PT_LOAD; all necessary information
242 should be covered by that. */
243 for (i
= 0; i
< n_hdrs
; i
++)
246 bfd_vma lma
= STATE_LOAD_AT_LMA_P (sd
)
247 ? phdr
[i
].p_paddr
: phdr
[i
].p_vaddr
;
249 if (phdr
[i
].p_type
!= PT_LOAD
)
252 buf
= xmalloc (phdr
[i
].p_filesz
);
256 "Loading segment at 0x%" BFD_VMA_FMT
"x, size 0x%lx\n",
257 lma
, phdr
[i
].p_filesz
);
259 if (bfd_seek (abfd
, phdr
[i
].p_offset
, SEEK_SET
) != 0
260 || (bfd_bread (buf
, phdr
[i
].p_filesz
, abfd
) != phdr
[i
].p_filesz
))
263 "%s: could not read segment at 0x%" BFD_VMA_FMT
"x, "
265 STATE_MY_NAME (sd
), lma
, phdr
[i
].p_filesz
);
270 if (do_write (sd
, lma
, buf
, phdr
[i
].p_filesz
) != phdr
[i
].p_filesz
)
273 "%s: could not load segment at 0x%" BFD_VMA_FMT
"x, "
275 STATE_MY_NAME (sd
), lma
, phdr
[i
].p_filesz
);
286 /* Cover function of sim_state_free to free the cpu buffers as well. */
289 free_state (SIM_DESC sd
)
291 if (STATE_MODULES (sd
) != NULL
)
292 sim_module_uninstall (sd
);
293 sim_cpu_free_all (sd
);
297 /* Helper struct for cris_set_section_offset_iterator. */
305 /* BFD section iterator to offset the LMA and VMA. */
308 cris_set_section_offset_iterator (bfd
*abfd
, asection
*s
, void *vp
)
310 struct offsetinfo
*p
= (struct offsetinfo
*) vp
;
312 int offset
= p
->offset
;
314 if ((bfd_section_flags (s
) & SEC_ALLOC
))
316 bfd_vma vma
= bfd_section_vma (s
);
318 bfd_set_section_vma (s
, vma
+ offset
);
321 /* This seems clumsy and inaccurate, but let's stick to doing it the
322 same way as sim_analyze_program for consistency. */
323 if (strcmp (bfd_section_name (s
), ".text") == 0)
324 STATE_TEXT_START (sd
) = bfd_section_vma (s
);
327 /* Adjust the start-address, LMA and VMA of a SD. Must be called
328 after sim_analyze_program. */
331 cris_offset_sections (SIM_DESC sd
, int offset
)
334 struct bfd
*abfd
= STATE_PROG_BFD (sd
);
336 struct offsetinfo oi
;
338 /* Only happens for usage error. */
345 bfd_map_over_sections (abfd
, cris_set_section_offset_iterator
, &oi
);
346 ret
= bfd_set_start_address (abfd
, bfd_get_start_address (abfd
) + offset
);
348 STATE_START_ADDR (sd
) = bfd_get_start_address (abfd
);
351 /* BFD section iterator to find the highest and lowest allocated and
352 non-allocated section addresses (plus one). */
355 get_progbounds_iterator (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*s
, void *vp
)
357 struct progbounds
*pbp
= (struct progbounds
*) vp
;
359 if ((bfd_section_flags (s
) & SEC_ALLOC
))
361 bfd_size_type sec_size
= bfd_section_size (s
);
362 bfd_size_type sec_start
= bfd_section_vma (s
);
363 bfd_size_type sec_end
= sec_start
+ sec_size
;
365 if (sec_end
> pbp
->endmem
)
366 pbp
->endmem
= sec_end
;
368 if (sec_start
< pbp
->startmem
)
369 pbp
->startmem
= sec_start
;
371 if ((bfd_section_flags (s
) & SEC_LOAD
))
373 if (sec_end
> pbp
->end_loadmem
)
374 pbp
->end_loadmem
= sec_end
;
376 else if (sec_start
< pbp
->start_nonloadmem
)
377 pbp
->start_nonloadmem
= sec_start
;
381 /* Get the program boundaries. Because not everything is covered by
382 sections in ELF, notably the program headers, we use the program
386 cris_get_progbounds (struct bfd
*abfd
, struct progbounds
*pbp
)
388 Elf_Internal_Phdr
*phdr
;
392 pbp
->startmem
= 0xffffffff;
394 pbp
->end_loadmem
= 0;
395 pbp
->start_nonloadmem
= 0xffffffff;
397 /* In case we're ever used for something other than ELF, use the
399 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
401 bfd_map_over_sections (abfd
, get_progbounds_iterator
, pbp
);
405 phdr
= elf_tdata (abfd
)->phdr
;
406 n_hdrs
= elf_elfheader (abfd
)->e_phnum
;
408 /* We're only interested in PT_LOAD; all necessary information
409 should be covered by that. */
410 for (i
= 0; i
< n_hdrs
; i
++)
412 if (phdr
[i
].p_type
!= PT_LOAD
)
415 if (phdr
[i
].p_paddr
< pbp
->startmem
)
416 pbp
->startmem
= phdr
[i
].p_paddr
;
418 if (phdr
[i
].p_paddr
+ phdr
[i
].p_memsz
> pbp
->endmem
)
419 pbp
->endmem
= phdr
[i
].p_paddr
+ phdr
[i
].p_memsz
;
421 if (phdr
[i
].p_paddr
+ phdr
[i
].p_filesz
> pbp
->end_loadmem
)
422 pbp
->end_loadmem
= phdr
[i
].p_paddr
+ phdr
[i
].p_filesz
;
424 if (phdr
[i
].p_memsz
> phdr
[i
].p_filesz
425 && phdr
[i
].p_paddr
+ phdr
[i
].p_filesz
< pbp
->start_nonloadmem
)
426 pbp
->start_nonloadmem
= phdr
[i
].p_paddr
+ phdr
[i
].p_filesz
;
430 /* Parameter communication by static variables, hmm... Oh well, for
432 static bfd_vma exec_load_addr
;
433 static bfd_vma interp_load_addr
;
434 static bfd_vma interp_start_addr
;
436 /* Supposed to mimic Linux' "NEW_AUX_ENT (AT_PHDR, load_addr + exec->e_phoff)". */
439 aux_ent_phdr (struct bfd
*ebfd
)
441 return elf_elfheader (ebfd
)->e_phoff
+ exec_load_addr
;
444 /* We just pass on the header info; we don't have our own idea of the
445 program header entry size. */
448 aux_ent_phent (struct bfd
*ebfd
)
450 return elf_elfheader (ebfd
)->e_phentsize
;
453 /* Like "NEW_AUX_ENT(AT_PHNUM, exec->e_phnum)". */
456 aux_ent_phnum (struct bfd
*ebfd
)
458 return elf_elfheader (ebfd
)->e_phnum
;
461 /* Like "NEW_AUX_ENT(AT_BASE, interp_load_addr)". */
464 aux_ent_base (struct bfd
*ebfd
)
466 return interp_load_addr
;
469 /* Like "NEW_AUX_ENT(AT_ENTRY, exec->e_entry)". */
472 aux_ent_entry (struct bfd
*ebfd
)
474 ASSERT (elf_elfheader (ebfd
)->e_entry
== bfd_get_start_address (ebfd
));
475 return elf_elfheader (ebfd
)->e_entry
;
478 /* Helper for cris_handle_interpreter: like sim_write, but load at
479 interp_load_addr offset. */
482 cris_write_interp (SIM_DESC sd
, SIM_ADDR mem
, const unsigned char *buf
, int length
)
484 return sim_write (sd
, mem
+ interp_load_addr
, buf
, length
);
487 /* Cater to the presence of an interpreter: load it and set
488 interp_start_addr. Return FALSE if there was an error, TRUE if
489 everything went fine, including an interpreter being absent and
490 the program being in a non-ELF format. */
493 cris_handle_interpreter (SIM_DESC sd
, struct bfd
*abfd
)
499 bfd_boolean ok
= FALSE
;
500 Elf_Internal_Phdr
*phdr
;
502 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
505 phdr
= elf_tdata (abfd
)->phdr
;
506 n_hdrs
= aux_ent_phnum (abfd
);
508 /* Check the program headers for presence of an interpreter. */
509 for (i
= 0; i
< n_hdrs
; i
++)
512 bfd_size_type interpsiz
, interp_filesiz
;
513 struct progbounds interp_bounds
;
515 if (phdr
[i
].p_type
!= PT_INTERP
)
518 /* Get the name of the interpreter, prepended with the sysroot
519 (empty if absent). */
520 interplen
= phdr
[i
].p_filesz
;
521 interp
= xmalloc (interplen
+ strlen (simulator_sysroot
));
522 strcpy (interp
, simulator_sysroot
);
524 /* Read in the name. */
525 if (bfd_seek (abfd
, phdr
[i
].p_offset
, SEEK_SET
) != 0
526 || (bfd_bread (interp
+ strlen (simulator_sysroot
), interplen
, abfd
)
528 goto interpname_failed
;
530 /* Like Linux, require the string to be 0-terminated. */
531 if (interp
[interplen
+ strlen (simulator_sysroot
) - 1] != 0)
532 goto interpname_failed
;
534 /* Inspect the interpreter. */
535 ibfd
= bfd_openr (interp
, STATE_TARGET (sd
));
537 goto interpname_failed
;
539 /* The interpreter is at least something readable to BFD; make
540 sure it's an ELF non-archive file. */
541 if (!bfd_check_format (ibfd
, bfd_object
)
542 || bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
545 /* Check the layout of the interpreter. */
546 cris_get_progbounds (ibfd
, &interp_bounds
);
548 /* Round down to pagesize the start page and up the endpage.
549 Don't round the *load and *nonload members. */
550 interp_bounds
.startmem
&= ~8191;
551 interp_bounds
.endmem
= (interp_bounds
.endmem
+ 8191) & ~8191;
553 /* Until we need a more dynamic solution, assume we can put the
554 interpreter at this fixed location. NB: this is not what
555 happens for Linux 2008-12-28, but it could and might and
557 interp_load_addr
= 0x40000;
558 interpsiz
= interp_bounds
.endmem
- interp_bounds
.startmem
;
559 interp_filesiz
= interp_bounds
.end_loadmem
- interp_bounds
.startmem
;
561 /* If we have a non-DSO or interpreter starting at the wrong
563 if (interp_bounds
.startmem
!= 0
564 || interpsiz
+ interp_load_addr
>= exec_load_addr
)
567 /* We don't have the API to get the address of a simulator
568 memory area, so we go via a temporary area. Luckily, the
569 interpreter is supposed to be small, less than 0x40000
571 sim_do_commandf (sd
, "memory region 0x%" BFD_VMA_FMT
"x,0x%lx",
572 interp_load_addr
, interpsiz
);
574 /* Now that memory for the interpreter is defined, load it. */
575 if (!cris_load_elf_file (sd
, ibfd
, cris_write_interp
))
578 /* It's no use setting STATE_START_ADDR, because it gets
579 overwritten by a sim_analyze_program call in sim_load. Let's
580 just store it locally. */
582 = (bfd_get_start_address (ibfd
)
583 - interp_bounds
.startmem
+ interp_load_addr
);
585 /* Linux cares only about the first PT_INTERP, so let's ignore
590 /* Register R10 should hold 0 at static start (no finifunc), but
591 that's the default, so don't bother. */
603 "%s: could not load ELF interpreter `%s' for program `%s'\n",
605 interp
== NULL
? "(what's-its-name)" : interp
,
606 bfd_get_filename (abfd
));
611 extern const SIM_MACH
* const cris_sim_machs
[];
613 /* Create an instance of the simulator. */
616 sim_open (SIM_OPEN_KIND kind
, host_callback
*callback
, struct bfd
*abfd
,
622 USI endmem
= CRIS_DEFAULT_MEM_SIZE
;
625 SIM_DESC sd
= sim_state_alloc (kind
, callback
);
627 static const struct auxv_entries_s
630 USI (*efn
) (struct bfd
*ebfd
);
634 #define AUX_ENT(a, b) {a, NULL, b}
635 #define AUX_ENTF(a, f) {a, f, 0}
636 AUX_ENT (AT_HWCAP
, 0),
637 AUX_ENT (AT_PAGESZ
, 8192),
638 AUX_ENT (AT_CLKTCK
, 100),
639 AUX_ENTF (AT_PHDR
, aux_ent_phdr
),
640 AUX_ENTF (AT_PHENT
, aux_ent_phent
),
641 AUX_ENTF (AT_PHNUM
, aux_ent_phnum
),
642 AUX_ENTF (AT_BASE
, aux_ent_base
),
643 AUX_ENT (AT_FLAGS
, 0),
644 AUX_ENTF (AT_ENTRY
, aux_ent_entry
),
646 /* Or is root better? Maybe have it settable? */
647 AUX_ENT (AT_UID
, 500),
648 AUX_ENT (AT_EUID
, 500),
649 AUX_ENT (AT_GID
, 500),
650 AUX_ENT (AT_EGID
, 500),
651 AUX_ENT (AT_SECURE
, 0),
655 /* Can't initialize to "" below. It's either a GCC bug in old
656 releases (up to and including 2.95.3 (.4 in debian) or a bug in the
657 standard ;-) that the rest of the elements won't be initialized. */
658 bfd_byte sp_init
[4] = {0, 0, 0, 0};
660 /* Set default options before parsing user options. */
661 STATE_MACHS (sd
) = cris_sim_machs
;
662 STATE_MODEL_NAME (sd
) = "crisv32";
663 current_target_byte_order
= BFD_ENDIAN_LITTLE
;
665 /* The cpu data is kept in a separately allocated chunk of memory. */
666 if (sim_cpu_alloc_all (sd
, 1) != SIM_RC_OK
)
672 if (sim_pre_argv_init (sd
, argv
[0]) != SIM_RC_OK
)
678 /* Add the CRIS-specific option list to the simulator. */
679 if (sim_add_option_table (sd
, NULL
, cris_options
) != SIM_RC_OK
)
685 /* The parser will print an error message for us, so we silently return. */
686 if (sim_parse_args (sd
, argv
) != SIM_RC_OK
)
692 /* check for/establish the reference program image */
693 if (sim_analyze_program (sd
,
694 (STATE_PROG_ARGV (sd
) != NULL
695 ? *STATE_PROG_ARGV (sd
)
699 /* When there's an error, sim_analyze_program has already output
700 a message. Let's just clarify it, as "not an object file"
701 perhaps doesn't ring a bell. */
702 sim_io_eprintf (sd
, "(not a CRIS program)\n");
707 /* We might get called with the caller expecting us to get hold of
708 the bfd for ourselves, which would happen at the
709 sim_analyze_program call above. */
711 abfd
= STATE_PROG_BFD (sd
);
713 /* Adjust the addresses of the program at this point. Unfortunately
714 this does not affect ELF program headers, so we have to handle
716 cris_offset_sections (sd
, cris_program_offset
);
718 if (abfd
!= NULL
&& bfd_get_arch (abfd
) == bfd_arch_unknown
)
720 if (STATE_PROG_ARGV (sd
) != NULL
)
721 sim_io_eprintf (sd
, "%s: `%s' is not a CRIS program\n",
722 STATE_MY_NAME (sd
), *STATE_PROG_ARGV (sd
));
724 sim_io_eprintf (sd
, "%s: program to be run is not a CRIS program\n",
730 /* For CRIS simulator-specific use, we need to find out the bounds of
731 the program as well, which is not done by sim_analyze_program
735 struct progbounds pb
;
737 /* The sections should now be accessible using bfd functions. */
738 cris_get_progbounds (abfd
, &pb
);
740 /* We align the area that the program uses to page boundaries. */
741 startmem
= pb
.startmem
& ~8191;
743 endmem
= (endbrk
+ 8191) & ~8191;
746 /* Find out how much room is needed for the environment and argv, create
747 that memory and fill it. Only do this when there's a program
749 if (abfd
!= NULL
&& !cris_bare_iron
)
751 const char *name
= bfd_get_filename (abfd
);
752 /* We use these maps to give the same behavior as the old xsim
754 USI envtop
= 0x40000000;
755 USI stacktop
= 0x3e000000;
758 int len
= strlen (name
) + 1;
762 char **prog_argv
= STATE_PROG_ARGV (sd
);
767 /* Count in the environment as well. */
768 for (envc
= 0; environ
[envc
] != NULL
; envc
++)
769 len
+= strlen (environ
[envc
]) + 1;
771 for (i
= 0; prog_argv
[i
] != NULL
; my_argc
++, i
++)
772 len
+= strlen (prog_argv
[i
]) + 1;
774 envstart
= (envtop
- len
) & ~8191;
776 /* Create read-only block for the environment strings. */
777 sim_core_attach (sd
, NULL
, 0, access_read
, 0,
778 envstart
, (len
+ 8191) & ~8191,
781 /* This shouldn't happen. */
782 if (envstart
< stacktop
)
783 stacktop
= envstart
- 64 * 8192;
787 /* Note that the linux kernel does not correctly compute the storage
788 needs for the static-exe AUX vector. */
790 csp
-= ARRAY_SIZE (auxv_entries
) * 4 * 2;
792 csp
-= (envc
+ 1) * 4;
793 csp
-= (my_argc
+ 1) * 4;
796 /* Write the target representation of the start-up-value for the
797 stack-pointer suitable for register initialization below. */
798 bfd_putl32 (csp
, sp_init
);
800 /* If we make this 1M higher; say 8192*1024, we have to take
801 special precautions for pthreads, because pthreads assumes that
802 the memory that low isn't mmapped, and that it can mmap it
803 without fallback in case of failure (and we fail ungracefully
804 long before *that*: the memory isn't accounted for in our mmap
806 stack_low
= (csp
- (7168*1024)) & ~8191;
808 stacklen
= stacktop
- stack_low
;
810 /* Tee hee, we have an executable stack. Well, it's necessary to
811 test GCC trampolines... */
812 sim_core_attach (sd
, NULL
, 0, access_read_write_exec
, 0,
816 epp
= epp0
= envstart
;
818 /* Can't use sim_core_write_unaligned_4 without everything
819 initialized when tracing, and then these writes would get into
821 #define write_dword(addr, data) \
826 bfd_putl32 (data_, buf); \
827 if (sim_core_write_buffer (sd, NULL, NULL_CIA, buf, addr_, 4) != 4)\
832 write_dword (csp
, my_argc
);
835 for (i
= 0; i
< my_argc
; i
++, csp
+= 4)
837 size_t strln
= strlen (prog_argv
[i
]) + 1;
839 if (sim_core_write_buffer (sd
, NULL
, NULL_CIA
, prog_argv
[i
], epp
,
844 write_dword (csp
, envstart
+ epp
- epp0
);
848 write_dword (csp
, 0);
851 for (i
= 0; i
< envc
; i
++, csp
+= 4)
853 unsigned int strln
= strlen (environ
[i
]) + 1;
855 if (sim_core_write_buffer (sd
, NULL
, NULL_CIA
, environ
[i
], epp
, strln
)
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
",0x%" PRIu32
,
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
, (unsigned 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 cris_set_callbacks (callback
);
957 sim_create_inferior (SIM_DESC sd
, struct bfd
*abfd
,
958 char * const *argv ATTRIBUTE_UNUSED
,
959 char * const *envp ATTRIBUTE_UNUSED
)
961 SIM_CPU
*current_cpu
= STATE_CPU (sd
, 0);
965 addr
= cris_start_address
!= (SIM_ADDR
) -1
967 : (interp_start_addr
!= 0
969 : bfd_get_start_address (abfd
));
972 sim_pc_set (current_cpu
, addr
);
974 /* Standalone mode (i.e. `run`) will take care of the argv for us in
975 sim_open() -> sim_parse_args(). But in debug mode (i.e. 'target sim'
976 with `gdb`), we need to handle it because the user can change the
977 argv on the fly via gdb's 'run'. */
978 if (STATE_PROG_ARGV (sd
) != argv
)
980 freeargv (STATE_PROG_ARGV (sd
));
981 STATE_PROG_ARGV (sd
) = dupargv (argv
);
987 /* Disassemble an instruction. */
990 cris_disassemble_insn (SIM_CPU
*cpu
,
991 const CGEN_INSN
*insn ATTRIBUTE_UNUSED
,
992 const ARGBUF
*abuf ATTRIBUTE_UNUSED
,
995 disassembler_ftype pinsn
;
996 struct disassemble_info disasm_info
;
998 SIM_DESC sd
= CPU_STATE (cpu
);
1000 sfile
.buffer
= sfile
.current
= buf
;
1001 INIT_DISASSEMBLE_INFO (disasm_info
, (FILE *) &sfile
,
1002 (fprintf_ftype
) sim_disasm_sprintf
);
1003 disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1004 disasm_info
.read_memory_func
= sim_disasm_read_memory
;
1005 disasm_info
.memory_error_func
= sim_disasm_perror_memory
;
1006 disasm_info
.application_data
= (PTR
) cpu
;
1007 pinsn
= cris_get_disassembler (STATE_PROG_BFD (sd
));
1008 (*pinsn
) (pc
, &disasm_info
);