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
23 /* This must come before any other includes. */
26 #include "libiberty.h"
34 #include "sim-options.h"
38 /* Used with get_progbounds to find out how much memory is needed for the
39 program. We don't want to allocate more, since that could mask
40 invalid memory accesses program bugs. */
48 static void free_state (SIM_DESC
);
49 static void get_progbounds_iterator (bfd
*, asection
*, void *);
50 static SIM_RC
cris_option_handler (SIM_DESC
, sim_cpu
*, int, char *, int);
52 /* Since we don't build the cgen-opcode table, we use the old
54 static CGEN_DISASSEMBLER cris_disassemble_insn
;
56 /* By default, we set up stack and environment variables like the Linux
58 static char cris_bare_iron
= 0;
60 /* Whether 0x9000000xx have simulator-specific meanings. */
61 char cris_have_900000xxif
= 0;
63 /* Used to optionally override the default start address of the
65 static USI cris_start_address
= 0xffffffffu
;
67 /* Used to optionally add offsets to the loaded image and its start
68 address. (Not used for the interpreter of dynamically loaded
69 programs or the DSO:s.) */
70 static int cris_program_offset
= 0;
72 /* What to do when we face a more or less unknown syscall. */
73 enum cris_unknown_syscall_action_type cris_unknown_syscall_action
74 = CRIS_USYSC_MSG_STOP
;
76 /* CRIS-specific options. */
78 OPTION_CRIS_STATS
= OPTION_START
,
81 OPTION_CRIS_PROGRAM_OFFSET
,
82 OPTION_CRIS_STARTADDR
,
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 { {"cris-program-offset", required_argument
, NULL
,
108 OPTION_CRIS_PROGRAM_OFFSET
},
110 "Offset image addresses and default start address of a program",
111 cris_option_handler
},
112 { {"cris-start-address", required_argument
, NULL
, OPTION_CRIS_STARTADDR
},
113 '\0', "ADDRESS", "Set start address",
114 cris_option_handler
},
115 { {NULL
, no_argument
, NULL
, 0}, '\0', NULL
, NULL
, NULL
, NULL
}
118 /* Handle CRIS-specific options. */
121 cris_option_handler (SIM_DESC sd
, sim_cpu
*cpu ATTRIBUTE_UNUSED
, int opt
,
122 char *arg
, int is_command ATTRIBUTE_UNUSED
)
124 /* The options are CRIS-specific, but cpu-specific option-handling is
125 broken; required to being with "--cpu0-". We store the flags in an
126 unused field in the global state structure and move the flags over
127 to the module-specific CPU data when we store things in the
128 cpu-specific structure. */
129 char *tracefp
= STATE_TRACE_FLAGS (sd
);
132 switch ((CRIS_OPTIONS
) opt
)
134 case OPTION_CRIS_STATS
:
135 if (strcmp (arg
, "basic") == 0)
136 *tracefp
= FLAG_CRIS_MISC_PROFILE_SIMPLE
;
137 else if (strcmp (arg
, "unaligned") == 0)
139 = (FLAG_CRIS_MISC_PROFILE_UNALIGNED
140 | FLAG_CRIS_MISC_PROFILE_SIMPLE
);
141 else if (strcmp (arg
, "schedulable") == 0)
143 = (FLAG_CRIS_MISC_PROFILE_SCHEDULABLE
144 | FLAG_CRIS_MISC_PROFILE_SIMPLE
);
145 else if (strcmp (arg
, "all") == 0)
146 *tracefp
= FLAG_CRIS_MISC_PROFILE_ALL
;
149 /* Beware; the framework does not handle the error case;
150 we have to do it ourselves. */
151 sim_io_eprintf (sd
, "Unknown option `--cris-cycles=%s'\n", arg
);
156 case OPTION_CRIS_TRACE
:
157 if (strcmp (arg
, "basic") == 0)
158 *tracefp
|= FLAG_CRIS_MISC_PROFILE_XSIM_TRACE
;
161 sim_io_eprintf (sd
, "Unknown option `--cris-trace=%s'\n", arg
);
166 case OPTION_CRIS_NAKED
:
170 case OPTION_CRIS_900000XXIF
:
171 cris_have_900000xxif
= 1;
174 case OPTION_CRIS_STARTADDR
:
176 cris_start_address
= (USI
) strtoul (chp
, &chp
, 0);
178 if (errno
!= 0 || *chp
!= 0)
180 sim_io_eprintf (sd
, "Invalid option `--cris-start-address=%s'\n",
186 case OPTION_CRIS_PROGRAM_OFFSET
:
188 cris_program_offset
= (int) strtol (chp
, &chp
, 0);
190 if (errno
!= 0 || *chp
!= 0)
192 sim_io_eprintf (sd
, "Invalid option `--cris-program-offset=%s'\n",
198 case OPTION_CRIS_UNKNOWN_SYSCALL
:
199 if (strcmp (arg
, "enosys") == 0)
200 cris_unknown_syscall_action
= CRIS_USYSC_MSG_ENOSYS
;
201 else if (strcmp (arg
, "enosys-quiet") == 0)
202 cris_unknown_syscall_action
= CRIS_USYSC_QUIET_ENOSYS
;
203 else if (strcmp (arg
, "stop") == 0)
204 cris_unknown_syscall_action
= CRIS_USYSC_MSG_STOP
;
207 sim_io_eprintf (sd
, "Unknown option `--cris-unknown-syscall=%s'\n",
214 /* We'll actually never get here; the caller handles the error
216 sim_io_eprintf (sd
, "Unknown option `%s'\n", arg
);
220 /* Imply --profile-model=on. */
221 return sim_profile_set_option (sd
, "-model", PROFILE_MODEL_IDX
, "on");
224 /* An ELF-specific simplified ../common/sim-load.c:sim_load_file,
225 using the program headers, not sections, in order to make sure that
226 the program headers themeselves are also loaded. The caller is
227 responsible for asserting that ABFD is an ELF file. */
230 cris_load_elf_file (SIM_DESC sd
, struct bfd
*abfd
, sim_write_fn do_write
)
232 Elf_Internal_Phdr
*phdr
;
235 bfd_boolean verbose
= STATE_OPEN_KIND (sd
) == SIM_OPEN_DEBUG
;
237 phdr
= elf_tdata (abfd
)->phdr
;
238 n_hdrs
= elf_elfheader (abfd
)->e_phnum
;
240 /* We're only interested in PT_LOAD; all necessary information
241 should be covered by that. */
242 for (i
= 0; i
< n_hdrs
; i
++)
245 bfd_vma lma
= STATE_LOAD_AT_LMA_P (sd
)
246 ? phdr
[i
].p_paddr
: phdr
[i
].p_vaddr
;
248 if (phdr
[i
].p_type
!= PT_LOAD
)
251 buf
= xmalloc (phdr
[i
].p_filesz
);
255 "Loading segment at 0x%" BFD_VMA_FMT
"x, size 0x%lx\n",
256 lma
, phdr
[i
].p_filesz
);
258 if (bfd_seek (abfd
, phdr
[i
].p_offset
, SEEK_SET
) != 0
259 || (bfd_bread (buf
, phdr
[i
].p_filesz
, abfd
) != phdr
[i
].p_filesz
))
262 "%s: could not read segment at 0x%" BFD_VMA_FMT
"x, "
264 STATE_MY_NAME (sd
), lma
, phdr
[i
].p_filesz
);
269 if (do_write (sd
, lma
, buf
, phdr
[i
].p_filesz
) != phdr
[i
].p_filesz
)
272 "%s: could not load segment at 0x%" BFD_VMA_FMT
"x, "
274 STATE_MY_NAME (sd
), lma
, phdr
[i
].p_filesz
);
285 /* Cover function of sim_state_free to free the cpu buffers as well. */
288 free_state (SIM_DESC sd
)
290 if (STATE_MODULES (sd
) != NULL
)
291 sim_module_uninstall (sd
);
292 sim_cpu_free_all (sd
);
296 /* Helper struct for cris_set_section_offset_iterator. */
304 /* BFD section iterator to offset the LMA and VMA. */
307 cris_set_section_offset_iterator (bfd
*abfd
, asection
*s
, void *vp
)
309 struct offsetinfo
*p
= (struct offsetinfo
*) vp
;
311 int offset
= p
->offset
;
313 if ((bfd_section_flags (s
) & SEC_ALLOC
))
315 bfd_vma vma
= bfd_section_vma (s
);
317 bfd_set_section_vma (s
, vma
+ offset
);
320 /* This seems clumsy and inaccurate, but let's stick to doing it the
321 same way as sim_analyze_program for consistency. */
322 if (strcmp (bfd_section_name (s
), ".text") == 0)
323 STATE_TEXT_START (sd
) = bfd_section_vma (s
);
326 /* Adjust the start-address, LMA and VMA of a SD. Must be called
327 after sim_analyze_program. */
330 cris_offset_sections (SIM_DESC sd
, int offset
)
333 struct bfd
*abfd
= STATE_PROG_BFD (sd
);
335 struct offsetinfo oi
;
337 /* Only happens for usage error. */
344 bfd_map_over_sections (abfd
, cris_set_section_offset_iterator
, &oi
);
345 ret
= bfd_set_start_address (abfd
, bfd_get_start_address (abfd
) + offset
);
347 STATE_START_ADDR (sd
) = bfd_get_start_address (abfd
);
350 /* BFD section iterator to find the highest and lowest allocated and
351 non-allocated section addresses (plus one). */
354 get_progbounds_iterator (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*s
, void *vp
)
356 struct progbounds
*pbp
= (struct progbounds
*) vp
;
358 if ((bfd_section_flags (s
) & SEC_ALLOC
))
360 bfd_size_type sec_size
= bfd_section_size (s
);
361 bfd_size_type sec_start
= bfd_section_vma (s
);
362 bfd_size_type sec_end
= sec_start
+ sec_size
;
364 if (sec_end
> pbp
->endmem
)
365 pbp
->endmem
= sec_end
;
367 if (sec_start
< pbp
->startmem
)
368 pbp
->startmem
= sec_start
;
370 if ((bfd_section_flags (s
) & SEC_LOAD
))
372 if (sec_end
> pbp
->end_loadmem
)
373 pbp
->end_loadmem
= sec_end
;
375 else if (sec_start
< pbp
->start_nonloadmem
)
376 pbp
->start_nonloadmem
= sec_start
;
380 /* Get the program boundaries. Because not everything is covered by
381 sections in ELF, notably the program headers, we use the program
385 cris_get_progbounds (struct bfd
*abfd
, struct progbounds
*pbp
)
387 Elf_Internal_Phdr
*phdr
;
391 pbp
->startmem
= 0xffffffff;
393 pbp
->end_loadmem
= 0;
394 pbp
->start_nonloadmem
= 0xffffffff;
396 /* In case we're ever used for something other than ELF, use the
398 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
400 bfd_map_over_sections (abfd
, get_progbounds_iterator
, pbp
);
404 phdr
= elf_tdata (abfd
)->phdr
;
405 n_hdrs
= elf_elfheader (abfd
)->e_phnum
;
407 /* We're only interested in PT_LOAD; all necessary information
408 should be covered by that. */
409 for (i
= 0; i
< n_hdrs
; i
++)
411 if (phdr
[i
].p_type
!= PT_LOAD
)
414 if (phdr
[i
].p_paddr
< pbp
->startmem
)
415 pbp
->startmem
= phdr
[i
].p_paddr
;
417 if (phdr
[i
].p_paddr
+ phdr
[i
].p_memsz
> pbp
->endmem
)
418 pbp
->endmem
= phdr
[i
].p_paddr
+ phdr
[i
].p_memsz
;
420 if (phdr
[i
].p_paddr
+ phdr
[i
].p_filesz
> pbp
->end_loadmem
)
421 pbp
->end_loadmem
= phdr
[i
].p_paddr
+ phdr
[i
].p_filesz
;
423 if (phdr
[i
].p_memsz
> phdr
[i
].p_filesz
424 && phdr
[i
].p_paddr
+ phdr
[i
].p_filesz
< pbp
->start_nonloadmem
)
425 pbp
->start_nonloadmem
= phdr
[i
].p_paddr
+ phdr
[i
].p_filesz
;
429 /* Parameter communication by static variables, hmm... Oh well, for
431 static bfd_vma exec_load_addr
;
432 static bfd_vma interp_load_addr
;
433 static bfd_vma interp_start_addr
;
435 /* Supposed to mimic Linux' "NEW_AUX_ENT (AT_PHDR, load_addr + exec->e_phoff)". */
438 aux_ent_phdr (struct bfd
*ebfd
)
440 return elf_elfheader (ebfd
)->e_phoff
+ exec_load_addr
;
443 /* We just pass on the header info; we don't have our own idea of the
444 program header entry size. */
447 aux_ent_phent (struct bfd
*ebfd
)
449 return elf_elfheader (ebfd
)->e_phentsize
;
452 /* Like "NEW_AUX_ENT(AT_PHNUM, exec->e_phnum)". */
455 aux_ent_phnum (struct bfd
*ebfd
)
457 return elf_elfheader (ebfd
)->e_phnum
;
460 /* Like "NEW_AUX_ENT(AT_BASE, interp_load_addr)". */
463 aux_ent_base (struct bfd
*ebfd
)
465 return interp_load_addr
;
468 /* Like "NEW_AUX_ENT(AT_ENTRY, exec->e_entry)". */
471 aux_ent_entry (struct bfd
*ebfd
)
473 ASSERT (elf_elfheader (ebfd
)->e_entry
== bfd_get_start_address (ebfd
));
474 return elf_elfheader (ebfd
)->e_entry
;
477 /* Helper for cris_handle_interpreter: like sim_write, but load at
478 interp_load_addr offset. */
481 cris_write_interp (SIM_DESC sd
, SIM_ADDR mem
, unsigned char *buf
, int length
)
483 return sim_write (sd
, mem
+ interp_load_addr
, buf
, length
);
486 /* Cater to the presence of an interpreter: load it and set
487 interp_start_addr. Return FALSE if there was an error, TRUE if
488 everything went fine, including an interpreter being absent and
489 the program being in a non-ELF format. */
492 cris_handle_interpreter (SIM_DESC sd
, struct bfd
*abfd
)
498 bfd_boolean ok
= FALSE
;
499 Elf_Internal_Phdr
*phdr
;
501 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
504 phdr
= elf_tdata (abfd
)->phdr
;
505 n_hdrs
= aux_ent_phnum (abfd
);
507 /* Check the program headers for presence of an interpreter. */
508 for (i
= 0; i
< n_hdrs
; i
++)
511 bfd_size_type interpsiz
, interp_filesiz
;
512 struct progbounds interp_bounds
;
514 if (phdr
[i
].p_type
!= PT_INTERP
)
517 /* Get the name of the interpreter, prepended with the sysroot
518 (empty if absent). */
519 interplen
= phdr
[i
].p_filesz
;
520 interp
= xmalloc (interplen
+ strlen (simulator_sysroot
));
521 strcpy (interp
, simulator_sysroot
);
523 /* Read in the name. */
524 if (bfd_seek (abfd
, phdr
[i
].p_offset
, SEEK_SET
) != 0
525 || (bfd_bread (interp
+ strlen (simulator_sysroot
), interplen
, abfd
)
527 goto interpname_failed
;
529 /* Like Linux, require the string to be 0-terminated. */
530 if (interp
[interplen
+ strlen (simulator_sysroot
) - 1] != 0)
531 goto interpname_failed
;
533 /* Inspect the interpreter. */
534 ibfd
= bfd_openr (interp
, STATE_TARGET (sd
));
536 goto interpname_failed
;
538 /* The interpreter is at least something readable to BFD; make
539 sure it's an ELF non-archive file. */
540 if (!bfd_check_format (ibfd
, bfd_object
)
541 || bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
544 /* Check the layout of the interpreter. */
545 cris_get_progbounds (ibfd
, &interp_bounds
);
547 /* Round down to pagesize the start page and up the endpage.
548 Don't round the *load and *nonload members. */
549 interp_bounds
.startmem
&= ~8191;
550 interp_bounds
.endmem
= (interp_bounds
.endmem
+ 8191) & ~8191;
552 /* Until we need a more dynamic solution, assume we can put the
553 interpreter at this fixed location. NB: this is not what
554 happens for Linux 2008-12-28, but it could and might and
556 interp_load_addr
= 0x40000;
557 interpsiz
= interp_bounds
.endmem
- interp_bounds
.startmem
;
558 interp_filesiz
= interp_bounds
.end_loadmem
- interp_bounds
.startmem
;
560 /* If we have a non-DSO or interpreter starting at the wrong
562 if (interp_bounds
.startmem
!= 0
563 || interpsiz
+ interp_load_addr
>= exec_load_addr
)
566 /* We don't have the API to get the address of a simulator
567 memory area, so we go via a temporary area. Luckily, the
568 interpreter is supposed to be small, less than 0x40000
570 sim_do_commandf (sd
, "memory region 0x%" BFD_VMA_FMT
"x,0x%lx",
571 interp_load_addr
, interpsiz
);
573 /* Now that memory for the interpreter is defined, load it. */
574 if (!cris_load_elf_file (sd
, ibfd
, cris_write_interp
))
577 /* It's no use setting STATE_START_ADDR, because it gets
578 overwritten by a sim_analyze_program call in sim_load. Let's
579 just store it locally. */
581 = (bfd_get_start_address (ibfd
)
582 - interp_bounds
.startmem
+ interp_load_addr
);
584 /* Linux cares only about the first PT_INTERP, so let's ignore
589 /* Register R10 should hold 0 at static start (no finifunc), but
590 that's the default, so don't bother. */
602 "%s: could not load ELF interpreter `%s' for program `%s'\n",
604 interp
== NULL
? "(what's-its-name)" : interp
,
605 bfd_get_filename (abfd
));
610 /* Create an instance of the simulator. */
613 sim_open (SIM_OPEN_KIND kind
, host_callback
*callback
, struct bfd
*abfd
,
619 USI endmem
= CRIS_DEFAULT_MEM_SIZE
;
622 SIM_DESC sd
= sim_state_alloc (kind
, callback
);
624 static const struct auxv_entries_s
627 USI (*efn
) (struct bfd
*ebfd
);
631 #define AUX_ENT(a, b) {a, NULL, b}
632 #define AUX_ENTF(a, f) {a, f, 0}
633 AUX_ENT (AT_HWCAP
, 0),
634 AUX_ENT (AT_PAGESZ
, 8192),
635 AUX_ENT (AT_CLKTCK
, 100),
636 AUX_ENTF (AT_PHDR
, aux_ent_phdr
),
637 AUX_ENTF (AT_PHENT
, aux_ent_phent
),
638 AUX_ENTF (AT_PHNUM
, aux_ent_phnum
),
639 AUX_ENTF (AT_BASE
, aux_ent_base
),
640 AUX_ENT (AT_FLAGS
, 0),
641 AUX_ENTF (AT_ENTRY
, aux_ent_entry
),
643 /* Or is root better? Maybe have it settable? */
644 AUX_ENT (AT_UID
, 500),
645 AUX_ENT (AT_EUID
, 500),
646 AUX_ENT (AT_GID
, 500),
647 AUX_ENT (AT_EGID
, 500),
648 AUX_ENT (AT_SECURE
, 0),
652 /* Can't initialize to "" below. It's either a GCC bug in old
653 releases (up to and including 2.95.3 (.4 in debian) or a bug in the
654 standard ;-) that the rest of the elements won't be initialized. */
655 bfd_byte sp_init
[4] = {0, 0, 0, 0};
657 /* The cpu data is kept in a separately allocated chunk of memory. */
658 if (sim_cpu_alloc_all (sd
, 1) != SIM_RC_OK
)
664 if (sim_pre_argv_init (sd
, argv
[0]) != SIM_RC_OK
)
670 /* Add the CRIS-specific option list to the simulator. */
671 if (sim_add_option_table (sd
, NULL
, cris_options
) != SIM_RC_OK
)
677 /* The parser will print an error message for us, so we silently return. */
678 if (sim_parse_args (sd
, argv
) != SIM_RC_OK
)
684 /* check for/establish the reference program image */
685 if (sim_analyze_program (sd
,
686 (STATE_PROG_ARGV (sd
) != NULL
687 ? *STATE_PROG_ARGV (sd
)
691 /* When there's an error, sim_analyze_program has already output
692 a message. Let's just clarify it, as "not an object file"
693 perhaps doesn't ring a bell. */
694 sim_io_eprintf (sd
, "(not a CRIS program)\n");
699 /* We might get called with the caller expecting us to get hold of
700 the bfd for ourselves, which would happen at the
701 sim_analyze_program call above. */
703 abfd
= STATE_PROG_BFD (sd
);
705 /* Adjust the addresses of the program at this point. Unfortunately
706 this does not affect ELF program headers, so we have to handle
708 cris_offset_sections (sd
, cris_program_offset
);
710 if (abfd
!= NULL
&& bfd_get_arch (abfd
) == bfd_arch_unknown
)
712 if (STATE_PROG_ARGV (sd
) != NULL
)
713 sim_io_eprintf (sd
, "%s: `%s' is not a CRIS program\n",
714 STATE_MY_NAME (sd
), *STATE_PROG_ARGV (sd
));
716 sim_io_eprintf (sd
, "%s: program to be run is not a CRIS program\n",
722 /* For CRIS simulator-specific use, we need to find out the bounds of
723 the program as well, which is not done by sim_analyze_program
727 struct progbounds pb
;
729 /* The sections should now be accessible using bfd functions. */
730 cris_get_progbounds (abfd
, &pb
);
732 /* We align the area that the program uses to page boundaries. */
733 startmem
= pb
.startmem
& ~8191;
735 endmem
= (endbrk
+ 8191) & ~8191;
738 /* Find out how much room is needed for the environment and argv, create
739 that memory and fill it. Only do this when there's a program
741 if (abfd
!= NULL
&& !cris_bare_iron
)
743 const char *name
= bfd_get_filename (abfd
);
744 /* We use these maps to give the same behavior as the old xsim
746 USI envtop
= 0x40000000;
747 USI stacktop
= 0x3e000000;
750 int len
= strlen (name
) + 1;
754 char **prog_argv
= STATE_PROG_ARGV (sd
);
759 /* Count in the environment as well. */
760 for (envc
= 0; environ
[envc
] != NULL
; envc
++)
761 len
+= strlen (environ
[envc
]) + 1;
763 for (i
= 0; prog_argv
[i
] != NULL
; my_argc
++, i
++)
764 len
+= strlen (prog_argv
[i
]) + 1;
766 envstart
= (envtop
- len
) & ~8191;
768 /* Create read-only block for the environment strings. */
769 sim_core_attach (sd
, NULL
, 0, access_read
, 0,
770 envstart
, (len
+ 8191) & ~8191,
773 /* This shouldn't happen. */
774 if (envstart
< stacktop
)
775 stacktop
= envstart
- 64 * 8192;
779 /* Note that the linux kernel does not correctly compute the storage
780 needs for the static-exe AUX vector. */
782 csp
-= ARRAY_SIZE (auxv_entries
) * 4 * 2;
784 csp
-= (envc
+ 1) * 4;
785 csp
-= (my_argc
+ 1) * 4;
788 /* Write the target representation of the start-up-value for the
789 stack-pointer suitable for register initialization below. */
790 bfd_putl32 (csp
, sp_init
);
792 /* If we make this 1M higher; say 8192*1024, we have to take
793 special precautions for pthreads, because pthreads assumes that
794 the memory that low isn't mmapped, and that it can mmap it
795 without fallback in case of failure (and we fail ungracefully
796 long before *that*: the memory isn't accounted for in our mmap
798 stack_low
= (csp
- (7168*1024)) & ~8191;
800 stacklen
= stacktop
- stack_low
;
802 /* Tee hee, we have an executable stack. Well, it's necessary to
803 test GCC trampolines... */
804 sim_core_attach (sd
, NULL
, 0, access_read_write_exec
, 0,
808 epp
= epp0
= envstart
;
810 /* Can't use sim_core_write_unaligned_4 without everything
811 initialized when tracing, and then these writes would get into
813 #define write_dword(addr, data) \
818 bfd_putl32 (data_, buf); \
819 if (sim_core_write_buffer (sd, NULL, NULL_CIA, buf, addr_, 4) != 4)\
824 write_dword (csp
, my_argc
);
827 for (i
= 0; i
< my_argc
; i
++, csp
+= 4)
829 size_t strln
= strlen (prog_argv
[i
]) + 1;
831 if (sim_core_write_buffer (sd
, NULL
, NULL_CIA
, prog_argv
[i
], epp
,
836 write_dword (csp
, envstart
+ epp
- epp0
);
840 write_dword (csp
, 0);
843 for (i
= 0; i
< envc
; i
++, csp
+= 4)
845 unsigned int strln
= strlen (environ
[i
]) + 1;
847 if (sim_core_write_buffer (sd
, NULL
, NULL_CIA
, environ
[i
], epp
, strln
)
851 write_dword (csp
, envstart
+ epp
- epp0
);
855 write_dword (csp
, 0);
858 /* The load address of the executable could presumably be
859 different than the lowest used memory address, but let's
860 stick to simplicity until needed. And
861 cris_handle_interpreter might change startmem and endmem, so
863 exec_load_addr
= startmem
;
865 if (!cris_handle_interpreter (sd
, abfd
))
868 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
869 for (i
= 0; i
< ARRAY_SIZE (auxv_entries
); i
++)
871 write_dword (csp
, auxv_entries
[i
].id
);
872 write_dword (csp
+ 4,
873 auxv_entries
[i
].efn
!= NULL
874 ? (*auxv_entries
[i
].efn
) (abfd
)
875 : auxv_entries
[i
].val
);
880 /* Allocate core managed memory if none specified by user. */
881 if (sim_core_read_buffer (sd
, NULL
, read_map
, &c
, startmem
, 1) == 0)
882 sim_do_commandf (sd
, "memory region 0x%" PRIx32
"x,0x%" PRIu32
"x",
883 startmem
, endmem
- startmem
);
885 /* Allocate simulator I/O managed memory if none specified by user. */
886 if (cris_have_900000xxif
)
887 sim_hw_parse (sd
, "/core/%s/reg %#x %i", "cris_900000xx", 0x90000000, 0x100);
889 /* Establish any remaining configuration options. */
890 if (sim_config (sd
) != SIM_RC_OK
)
897 if (sim_post_argv_init (sd
) != SIM_RC_OK
)
903 /* Open a copy of the cpu descriptor table. */
905 CGEN_CPU_DESC cd
= cris_cgen_cpu_open_1 (STATE_ARCHITECTURE (sd
)->printable_name
,
907 for (i
= 0; i
< MAX_NR_PROCESSORS
; ++i
)
909 SIM_CPU
*cpu
= STATE_CPU (sd
, i
);
910 CPU_CPU_DESC (cpu
) = cd
;
911 CPU_DISASSEMBLER (cpu
) = cris_disassemble_insn
;
913 /* See cris_option_handler for the reason why this is needed. */
914 CPU_CRIS_MISC_PROFILE (cpu
)->flags
= STATE_TRACE_FLAGS (sd
)[0];
916 /* Set SP to the stack we allocated above. */
917 (* CPU_REG_STORE (cpu
)) (cpu
, H_GR_SP
, (char *) sp_init
, 4);
919 /* Set the simulator environment data. */
920 cpu
->highest_mmapped_page
= NULL
;
921 cpu
->endmem
= endmem
;
922 cpu
->endbrk
= endbrk
;
923 cpu
->stack_low
= stack_low
;
927 cpu
->max_threadid
= 0;
928 cpu
->thread_data
= NULL
;
929 memset (cpu
->sighandler
, 0, sizeof (cpu
->sighandler
));
930 cpu
->make_thread_cpu_data
= NULL
;
931 cpu
->thread_cpu_data_size
= 0;
933 cpu
->deliver_interrupt
= NULL
;
937 /* Always be cycle-accurate and call before/after functions if
939 sim_profile_set_option (sd
, "-model", PROFILE_MODEL_IDX
, "on");
943 /* Initialize various cgen things not done by common framework.
944 Must be done after cris_cgen_cpu_open. */
947 cris_set_callbacks (callback
);
953 sim_create_inferior (SIM_DESC sd
, struct bfd
*abfd
,
954 char * const *argv ATTRIBUTE_UNUSED
,
955 char * const *envp ATTRIBUTE_UNUSED
)
957 SIM_CPU
*current_cpu
= STATE_CPU (sd
, 0);
961 addr
= cris_start_address
!= (SIM_ADDR
) -1
963 : (interp_start_addr
!= 0
965 : bfd_get_start_address (abfd
));
968 sim_pc_set (current_cpu
, addr
);
970 /* Standalone mode (i.e. `run`) will take care of the argv for us in
971 sim_open() -> sim_parse_args(). But in debug mode (i.e. 'target sim'
972 with `gdb`), we need to handle it because the user can change the
973 argv on the fly via gdb's 'run'. */
974 if (STATE_PROG_ARGV (sd
) != argv
)
976 freeargv (STATE_PROG_ARGV (sd
));
977 STATE_PROG_ARGV (sd
) = dupargv (argv
);
983 /* Disassemble an instruction. */
986 cris_disassemble_insn (SIM_CPU
*cpu
,
987 const CGEN_INSN
*insn ATTRIBUTE_UNUSED
,
988 const ARGBUF
*abuf ATTRIBUTE_UNUSED
,
991 disassembler_ftype pinsn
;
992 struct disassemble_info disasm_info
;
994 SIM_DESC sd
= CPU_STATE (cpu
);
996 sfile
.buffer
= sfile
.current
= buf
;
997 INIT_DISASSEMBLE_INFO (disasm_info
, (FILE *) &sfile
,
998 (fprintf_ftype
) sim_disasm_sprintf
);
999 disasm_info
.endian
= BFD_ENDIAN_LITTLE
;
1000 disasm_info
.read_memory_func
= sim_disasm_read_memory
;
1001 disasm_info
.memory_error_func
= sim_disasm_perror_memory
;
1002 disasm_info
.application_data
= (PTR
) cpu
;
1003 pinsn
= cris_get_disassembler (STATE_PROG_BFD (sd
));
1004 (*pinsn
) (pc
, &disasm_info
);