1 /* Main simulator entry points specific to the CRIS.
2 Copyright (C) 2004-2020 Free Software Foundation, Inc.
3 Contributed by Axis Communications.
4
5 This file is part of the GNU simulators.
6
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.
11
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.
16
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/>. */
19
20 /* Based on the fr30 file, mixing in bits from the i960 and pruning of
21 dead code. */
22
23 #include "config.h"
24 #include "libiberty.h"
25 #include "bfd.h"
26 #include "elf-bfd.h"
27
28 #include "sim-main.h"
29 #ifdef HAVE_STDLIB_H
30 #include <stdlib.h>
31 #endif
32 #include <errno.h>
33 #include "sim-options.h"
34 #include "dis-asm.h"
35
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
41 #else
42 char *missing_environ[] = { "SHELL=/bin/sh", "PATH=/bin:/usr/bin", NULL };
43 #define GET_ENVIRON() missing_environ
44 #endif
45
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. */
49 struct progbounds {
50 USI startmem;
51 USI endmem;
52 USI end_loadmem;
53 USI start_nonloadmem;
54 };
55
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);
59
60 /* Since we don't build the cgen-opcode table, we use the old
61 disassembler. */
62 static CGEN_DISASSEMBLER cris_disassemble_insn;
63
64 /* By default, we set up stack and environment variables like the Linux
65 kernel. */
66 static char cris_bare_iron = 0;
67
68 /* Whether 0x9000000xx have simulator-specific meanings. */
69 char cris_have_900000xxif = 0;
70
71 /* Used to optionally override the default start address of the
72 simulation. */
73 static USI cris_start_address = 0xffffffffu;
74
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;
79
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;
83
84 /* CRIS-specific options. */
85 typedef enum {
86 OPTION_CRIS_STATS = OPTION_START,
87 OPTION_CRIS_TRACE,
88 OPTION_CRIS_NAKED,
89 OPTION_CRIS_PROGRAM_OFFSET,
90 OPTION_CRIS_STARTADDR,
91 OPTION_CRIS_900000XXIF,
92 OPTION_CRIS_UNKNOWN_SYSCALL
93 } CRIS_OPTIONS;
94
95 static const OPTION cris_options[] =
96 {
97 { {"cris-cycles", required_argument, NULL, OPTION_CRIS_STATS},
98 '\0', "basic|unaligned|schedulable|all",
99 "Dump execution statistics",
100 cris_option_handler, NULL },
101 { {"cris-trace", required_argument, NULL, OPTION_CRIS_TRACE},
102 '\0', "basic",
103 "Emit trace information while running",
104 cris_option_handler, NULL },
105 { {"cris-naked", no_argument, NULL, OPTION_CRIS_NAKED},
106 '\0', NULL, "Don't set up stack and environment",
107 cris_option_handler, NULL },
108 { {"cris-900000xx", no_argument, NULL, OPTION_CRIS_900000XXIF},
109 '\0', NULL, "Define addresses at 0x900000xx with simulator semantics",
110 cris_option_handler, NULL },
111 { {"cris-unknown-syscall", required_argument, NULL,
112 OPTION_CRIS_UNKNOWN_SYSCALL},
113 '\0', "stop|enosys|enosys-quiet", "Action at an unknown system call",
114 cris_option_handler, NULL },
115 { {"cris-program-offset", required_argument, NULL,
116 OPTION_CRIS_PROGRAM_OFFSET},
117 '\0', "OFFSET",
118 "Offset image addresses and default start address of a program",
119 cris_option_handler },
120 { {"cris-start-address", required_argument, NULL, OPTION_CRIS_STARTADDR},
121 '\0', "ADDRESS", "Set start address",
122 cris_option_handler },
123 { {NULL, no_argument, NULL, 0}, '\0', NULL, NULL, NULL, NULL }
124 };
125
126 /* Handle CRIS-specific options. */
127
128 static SIM_RC
cris_option_handler(SIM_DESC sd,sim_cpu * cpu ATTRIBUTE_UNUSED,int opt,char * arg,int is_command ATTRIBUTE_UNUSED)129 cris_option_handler (SIM_DESC sd, sim_cpu *cpu ATTRIBUTE_UNUSED, int opt,
130 char *arg, int is_command ATTRIBUTE_UNUSED)
131 {
132 /* The options are CRIS-specific, but cpu-specific option-handling is
133 broken; required to being with "--cpu0-". We store the flags in an
134 unused field in the global state structure and move the flags over
135 to the module-specific CPU data when we store things in the
136 cpu-specific structure. */
137 char *tracefp = STATE_TRACE_FLAGS (sd);
138 char *chp = arg;
139
140 switch ((CRIS_OPTIONS) opt)
141 {
142 case OPTION_CRIS_STATS:
143 if (strcmp (arg, "basic") == 0)
144 *tracefp = FLAG_CRIS_MISC_PROFILE_SIMPLE;
145 else if (strcmp (arg, "unaligned") == 0)
146 *tracefp
147 = (FLAG_CRIS_MISC_PROFILE_UNALIGNED
148 | FLAG_CRIS_MISC_PROFILE_SIMPLE);
149 else if (strcmp (arg, "schedulable") == 0)
150 *tracefp
151 = (FLAG_CRIS_MISC_PROFILE_SCHEDULABLE
152 | FLAG_CRIS_MISC_PROFILE_SIMPLE);
153 else if (strcmp (arg, "all") == 0)
154 *tracefp = FLAG_CRIS_MISC_PROFILE_ALL;
155 else
156 {
157 /* Beware; the framework does not handle the error case;
158 we have to do it ourselves. */
159 sim_io_eprintf (sd, "Unknown option `--cris-cycles=%s'\n", arg);
160 return SIM_RC_FAIL;
161 }
162 break;
163
164 case OPTION_CRIS_TRACE:
165 if (strcmp (arg, "basic") == 0)
166 *tracefp |= FLAG_CRIS_MISC_PROFILE_XSIM_TRACE;
167 else
168 {
169 sim_io_eprintf (sd, "Unknown option `--cris-trace=%s'\n", arg);
170 return SIM_RC_FAIL;
171 }
172 break;
173
174 case OPTION_CRIS_NAKED:
175 cris_bare_iron = 1;
176 break;
177
178 case OPTION_CRIS_900000XXIF:
179 cris_have_900000xxif = 1;
180 break;
181
182 case OPTION_CRIS_STARTADDR:
183 errno = 0;
184 cris_start_address = (USI) strtoul (chp, &chp, 0);
185
186 if (errno != 0 || *chp != 0)
187 {
188 sim_io_eprintf (sd, "Invalid option `--cris-start-address=%s'\n",
189 arg);
190 return SIM_RC_FAIL;
191 }
192 break;
193
194 case OPTION_CRIS_PROGRAM_OFFSET:
195 errno = 0;
196 cris_program_offset = (int) strtol (chp, &chp, 0);
197
198 if (errno != 0 || *chp != 0)
199 {
200 sim_io_eprintf (sd, "Invalid option `--cris-program-offset=%s'\n",
201 arg);
202 return SIM_RC_FAIL;
203 }
204 break;
205
206 case OPTION_CRIS_UNKNOWN_SYSCALL:
207 if (strcmp (arg, "enosys") == 0)
208 cris_unknown_syscall_action = CRIS_USYSC_MSG_ENOSYS;
209 else if (strcmp (arg, "enosys-quiet") == 0)
210 cris_unknown_syscall_action = CRIS_USYSC_QUIET_ENOSYS;
211 else if (strcmp (arg, "stop") == 0)
212 cris_unknown_syscall_action = CRIS_USYSC_MSG_STOP;
213 else
214 {
215 sim_io_eprintf (sd, "Unknown option `--cris-unknown-syscall=%s'\n",
216 arg);
217 return SIM_RC_FAIL;
218 }
219 break;
220
221 default:
222 /* We'll actually never get here; the caller handles the error
223 case. */
224 sim_io_eprintf (sd, "Unknown option `%s'\n", arg);
225 return SIM_RC_FAIL;
226 }
227
228 /* Imply --profile-model=on. */
229 return sim_profile_set_option (sd, "-model", PROFILE_MODEL_IDX, "on");
230 }
231
232 /* An ELF-specific simplified ../common/sim-load.c:sim_load_file,
233 using the program headers, not sections, in order to make sure that
234 the program headers themeselves are also loaded. The caller is
235 responsible for asserting that ABFD is an ELF file. */
236
237 static bfd_boolean
cris_load_elf_file(SIM_DESC sd,struct bfd * abfd,sim_write_fn do_write)238 cris_load_elf_file (SIM_DESC sd, struct bfd *abfd, sim_write_fn do_write)
239 {
240 Elf_Internal_Phdr *phdr;
241 int n_hdrs;
242 int i;
243 bfd_boolean verbose = STATE_OPEN_KIND (sd) == SIM_OPEN_DEBUG;
244
245 phdr = elf_tdata (abfd)->phdr;
246 n_hdrs = elf_elfheader (abfd)->e_phnum;
247
248 /* We're only interested in PT_LOAD; all necessary information
249 should be covered by that. */
250 for (i = 0; i < n_hdrs; i++)
251 {
252 bfd_byte *buf;
253 bfd_vma lma = STATE_LOAD_AT_LMA_P (sd)
254 ? phdr[i].p_paddr : phdr[i].p_vaddr;
255
256 if (phdr[i].p_type != PT_LOAD)
257 continue;
258
259 buf = xmalloc (phdr[i].p_filesz);
260
261 if (verbose)
262 sim_io_printf (sd, "Loading segment at 0x%lx, size 0x%lx\n",
263 lma, phdr[i].p_filesz);
264
265 if (bfd_seek (abfd, phdr[i].p_offset, SEEK_SET) != 0
266 || (bfd_bread (buf, phdr[i].p_filesz, abfd) != phdr[i].p_filesz))
267 {
268 sim_io_eprintf (sd,
269 "%s: could not read segment at 0x%lx, size 0x%lx\n",
270 STATE_MY_NAME (sd), lma, phdr[i].p_filesz);
271 free (buf);
272 return FALSE;
273 }
274
275 if (do_write (sd, lma, buf, phdr[i].p_filesz) != phdr[i].p_filesz)
276 {
277 sim_io_eprintf (sd,
278 "%s: could not load segment at 0x%lx, size 0x%lx\n",
279 STATE_MY_NAME (sd), lma, phdr[i].p_filesz);
280 free (buf);
281 return FALSE;
282 }
283
284 free (buf);
285 }
286
287 return TRUE;
288 }
289
290 /* Cover function of sim_state_free to free the cpu buffers as well. */
291
292 static void
free_state(SIM_DESC sd)293 free_state (SIM_DESC sd)
294 {
295 if (STATE_MODULES (sd) != NULL)
296 sim_module_uninstall (sd);
297 sim_cpu_free_all (sd);
298 sim_state_free (sd);
299 }
300
301 /* Helper struct for cris_set_section_offset_iterator. */
302
303 struct offsetinfo
304 {
305 SIM_DESC sd;
306 int offset;
307 };
308
309 /* BFD section iterator to offset the LMA and VMA. */
310
311 static void
cris_set_section_offset_iterator(bfd * abfd,asection * s,void * vp)312 cris_set_section_offset_iterator (bfd *abfd, asection *s, void *vp)
313 {
314 struct offsetinfo *p = (struct offsetinfo *) vp;
315 SIM_DESC sd = p->sd;
316 int offset = p->offset;
317
318 if ((bfd_section_flags (s) & SEC_ALLOC))
319 {
320 bfd_vma vma = bfd_section_vma (s);
321
322 bfd_set_section_vma (s, vma + offset);
323 }
324
325 /* This seems clumsy and inaccurate, but let's stick to doing it the
326 same way as sim_analyze_program for consistency. */
327 if (strcmp (bfd_section_name (s), ".text") == 0)
328 STATE_TEXT_START (sd) = bfd_section_vma (s);
329 }
330
331 /* Adjust the start-address, LMA and VMA of a SD. Must be called
332 after sim_analyze_program. */
333
334 static void
cris_offset_sections(SIM_DESC sd,int offset)335 cris_offset_sections (SIM_DESC sd, int offset)
336 {
337 bfd_boolean ret;
338 struct bfd *abfd = STATE_PROG_BFD (sd);
339 asection *text;
340 struct offsetinfo oi;
341
342 /* Only happens for usage error. */
343 if (abfd == NULL)
344 return;
345
346 oi.sd = sd;
347 oi.offset = offset;
348
349 bfd_map_over_sections (abfd, cris_set_section_offset_iterator, &oi);
350 ret = bfd_set_start_address (abfd, bfd_get_start_address (abfd) + offset);
351
352 STATE_START_ADDR (sd) = bfd_get_start_address (abfd);
353 }
354
355 /* BFD section iterator to find the highest and lowest allocated and
356 non-allocated section addresses (plus one). */
357
358 static void
get_progbounds_iterator(bfd * abfd ATTRIBUTE_UNUSED,asection * s,void * vp)359 get_progbounds_iterator (bfd *abfd ATTRIBUTE_UNUSED, asection *s, void *vp)
360 {
361 struct progbounds *pbp = (struct progbounds *) vp;
362
363 if ((bfd_section_flags (s) & SEC_ALLOC))
364 {
365 bfd_size_type sec_size = bfd_section_size (s);
366 bfd_size_type sec_start = bfd_section_vma (s);
367 bfd_size_type sec_end = sec_start + sec_size;
368
369 if (sec_end > pbp->endmem)
370 pbp->endmem = sec_end;
371
372 if (sec_start < pbp->startmem)
373 pbp->startmem = sec_start;
374
375 if ((bfd_section_flags (s) & SEC_LOAD))
376 {
377 if (sec_end > pbp->end_loadmem)
378 pbp->end_loadmem = sec_end;
379 }
380 else if (sec_start < pbp->start_nonloadmem)
381 pbp->start_nonloadmem = sec_start;
382 }
383 }
384
385 /* Get the program boundaries. Because not everything is covered by
386 sections in ELF, notably the program headers, we use the program
387 headers instead. */
388
389 static void
cris_get_progbounds(struct bfd * abfd,struct progbounds * pbp)390 cris_get_progbounds (struct bfd *abfd, struct progbounds *pbp)
391 {
392 Elf_Internal_Phdr *phdr;
393 int n_hdrs;
394 int i;
395
396 pbp->startmem = 0xffffffff;
397 pbp->endmem = 0;
398 pbp->end_loadmem = 0;
399 pbp->start_nonloadmem = 0xffffffff;
400
401 /* In case we're ever used for something other than ELF, use the
402 generic method. */
403 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
404 {
405 bfd_map_over_sections (abfd, get_progbounds_iterator, pbp);
406 return;
407 }
408
409 phdr = elf_tdata (abfd)->phdr;
410 n_hdrs = elf_elfheader (abfd)->e_phnum;
411
412 /* We're only interested in PT_LOAD; all necessary information
413 should be covered by that. */
414 for (i = 0; i < n_hdrs; i++)
415 {
416 if (phdr[i].p_type != PT_LOAD)
417 continue;
418
419 if (phdr[i].p_paddr < pbp->startmem)
420 pbp->startmem = phdr[i].p_paddr;
421
422 if (phdr[i].p_paddr + phdr[i].p_memsz > pbp->endmem)
423 pbp->endmem = phdr[i].p_paddr + phdr[i].p_memsz;
424
425 if (phdr[i].p_paddr + phdr[i].p_filesz > pbp->end_loadmem)
426 pbp->end_loadmem = phdr[i].p_paddr + phdr[i].p_filesz;
427
428 if (phdr[i].p_memsz > phdr[i].p_filesz
429 && phdr[i].p_paddr + phdr[i].p_filesz < pbp->start_nonloadmem)
430 pbp->start_nonloadmem = phdr[i].p_paddr + phdr[i].p_filesz;
431 }
432 }
433
434 /* Parameter communication by static variables, hmm... Oh well, for
435 simplicity. */
436 static bfd_vma exec_load_addr;
437 static bfd_vma interp_load_addr;
438 static bfd_vma interp_start_addr;
439
440 /* Supposed to mimic Linux' "NEW_AUX_ENT (AT_PHDR, load_addr + exec->e_phoff)". */
441
442 static USI
aux_ent_phdr(struct bfd * ebfd)443 aux_ent_phdr (struct bfd *ebfd)
444 {
445 return elf_elfheader (ebfd)->e_phoff + exec_load_addr;
446 }
447
448 /* We just pass on the header info; we don't have our own idea of the
449 program header entry size. */
450
451 static USI
aux_ent_phent(struct bfd * ebfd)452 aux_ent_phent (struct bfd *ebfd)
453 {
454 return elf_elfheader (ebfd)->e_phentsize;
455 }
456
457 /* Like "NEW_AUX_ENT(AT_PHNUM, exec->e_phnum)". */
458
459 static USI
aux_ent_phnum(struct bfd * ebfd)460 aux_ent_phnum (struct bfd *ebfd)
461 {
462 return elf_elfheader (ebfd)->e_phnum;
463 }
464
465 /* Like "NEW_AUX_ENT(AT_BASE, interp_load_addr)". */
466
467 static USI
aux_ent_base(struct bfd * ebfd)468 aux_ent_base (struct bfd *ebfd)
469 {
470 return interp_load_addr;
471 }
472
473 /* Like "NEW_AUX_ENT(AT_ENTRY, exec->e_entry)". */
474
475 static USI
aux_ent_entry(struct bfd * ebfd)476 aux_ent_entry (struct bfd *ebfd)
477 {
478 ASSERT (elf_elfheader (ebfd)->e_entry == bfd_get_start_address (ebfd));
479 return elf_elfheader (ebfd)->e_entry;
480 }
481
482 /* Helper for cris_handle_interpreter: like sim_write, but load at
483 interp_load_addr offset. */
484
485 static int
cris_write_interp(SIM_DESC sd,SIM_ADDR mem,unsigned char * buf,int length)486 cris_write_interp (SIM_DESC sd, SIM_ADDR mem, unsigned char *buf, int length)
487 {
488 return sim_write (sd, mem + interp_load_addr, buf, length);
489 }
490
491 /* Cater to the presence of an interpreter: load it and set
492 interp_start_addr. Return FALSE if there was an error, TRUE if
493 everything went fine, including an interpreter being absent and
494 the program being in a non-ELF format. */
495
496 static bfd_boolean
cris_handle_interpreter(SIM_DESC sd,struct bfd * abfd)497 cris_handle_interpreter (SIM_DESC sd, struct bfd *abfd)
498 {
499 int i, n_hdrs;
500 bfd_vma phaddr;
501 bfd_byte buf[4];
502 char *interp = NULL;
503 struct bfd *ibfd;
504 bfd_boolean ok = FALSE;
505 Elf_Internal_Phdr *phdr;
506
507 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
508 return TRUE;
509
510 phdr = elf_tdata (abfd)->phdr;
511 n_hdrs = aux_ent_phnum (abfd);
512
513 /* Check the program headers for presence of an interpreter. */
514 for (i = 0; i < n_hdrs; i++)
515 {
516 int interplen;
517 bfd_size_type interpsiz, interp_filesiz;
518 struct progbounds interp_bounds;
519
520 if (phdr[i].p_type != PT_INTERP)
521 continue;
522
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);
528
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)
532 != interplen))
533 goto interpname_failed;
534
535 /* Like Linux, require the string to be 0-terminated. */
536 if (interp[interplen + strlen (simulator_sysroot) - 1] != 0)
537 goto interpname_failed;
538
539 /* Inspect the interpreter. */
540 ibfd = bfd_openr (interp, STATE_TARGET (sd));
541 if (ibfd == NULL)
542 goto interpname_failed;
543
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)
548 goto interp_failed;
549
550 /* Check the layout of the interpreter. */
551 cris_get_progbounds (ibfd, &interp_bounds);
552
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;
557
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
561 perhaps should. */
562 interp_load_addr = 0x40000;
563 interpsiz = interp_bounds.endmem - interp_bounds.startmem;
564 interp_filesiz = interp_bounds.end_loadmem - interp_bounds.startmem;
565
566 /* If we have a non-DSO or interpreter starting at the wrong
567 address, bail. */
568 if (interp_bounds.startmem != 0
569 || interpsiz + interp_load_addr >= exec_load_addr)
570 goto interp_failed;
571
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
575 bytes. */
576 sim_do_commandf (sd, "memory region 0x%lx,0x%lx",
577 interp_load_addr, interpsiz);
578
579 /* Now that memory for the interpreter is defined, load it. */
580 if (!cris_load_elf_file (sd, ibfd, cris_write_interp))
581 goto interp_failed;
582
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. */
586 interp_start_addr
587 = (bfd_get_start_address (ibfd)
588 - interp_bounds.startmem + interp_load_addr);
589
590 /* Linux cares only about the first PT_INTERP, so let's ignore
591 the rest. */
592 goto all_done;
593 }
594
595 /* Register R10 should hold 0 at static start (no finifunc), but
596 that's the default, so don't bother. */
597 return TRUE;
598
599 all_done:
600 ok = TRUE;
601
602 interp_failed:
603 bfd_close (ibfd);
604
605 interpname_failed:
606 if (!ok)
607 sim_io_eprintf (sd,
608 "%s: could not load ELF interpreter `%s' for program `%s'\n",
609 STATE_MY_NAME (sd),
610 interp == NULL ? "(what's-its-name)" : interp,
611 bfd_get_filename (abfd));
612 free (interp);
613 return ok;
614 }
615
616 /* Create an instance of the simulator. */
617
618 SIM_DESC
sim_open(SIM_OPEN_KIND kind,host_callback * callback,struct bfd * abfd,char * const * argv)619 sim_open (SIM_OPEN_KIND kind, host_callback *callback, struct bfd *abfd,
620 char * const *argv)
621 {
622 char c;
623 int i;
624 USI startmem = 0;
625 USI endmem = CRIS_DEFAULT_MEM_SIZE;
626 USI endbrk = endmem;
627 USI stack_low = 0;
628 SIM_DESC sd = sim_state_alloc (kind, callback);
629
630 static const struct auxv_entries_s
631 {
632 bfd_byte id;
633 USI (*efn) (struct bfd *ebfd);
634 USI val;
635 } auxv_entries[] =
636 {
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),
648
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),
655 AUX_ENT (AT_NULL, 0)
656 };
657
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};
662
663 /* The cpu data is kept in a separately allocated chunk of memory. */
664 if (sim_cpu_alloc_all (sd, 1, cgen_cpu_max_extra_bytes ()) != SIM_RC_OK)
665 {
666 free_state (sd);
667 return 0;
668 }
669
670 if (sim_pre_argv_init (sd, argv[0]) != SIM_RC_OK)
671 {
672 free_state (sd);
673 return 0;
674 }
675
676 /* Add the CRIS-specific option list to the simulator. */
677 if (sim_add_option_table (sd, NULL, cris_options) != SIM_RC_OK)
678 {
679 free_state (sd);
680 return 0;
681 }
682
683 /* The parser will print an error message for us, so we silently return. */
684 if (sim_parse_args (sd, argv) != SIM_RC_OK)
685 {
686 free_state (sd);
687 return 0;
688 }
689
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)
694 : NULL),
695 abfd) != SIM_RC_OK)
696 {
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");
701 free_state (sd);
702 return 0;
703 }
704
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. */
708 if (abfd == NULL)
709 abfd = STATE_PROG_BFD (sd);
710
711 /* Adjust the addresses of the program at this point. Unfortunately
712 this does not affect ELF program headers, so we have to handle
713 that separately. */
714 cris_offset_sections (sd, cris_program_offset);
715
716 if (abfd != NULL && bfd_get_arch (abfd) == bfd_arch_unknown)
717 {
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));
721 else
722 sim_io_eprintf (sd, "%s: program to be run is not a CRIS program\n",
723 STATE_MY_NAME (sd));
724 free_state (sd);
725 return 0;
726 }
727
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
730 above. */
731 if (abfd != NULL)
732 {
733 struct progbounds pb;
734
735 /* The sections should now be accessible using bfd functions. */
736 cris_get_progbounds (abfd, &pb);
737
738 /* We align the area that the program uses to page boundaries. */
739 startmem = pb.startmem & ~8191;
740 endbrk = pb.endmem;
741 endmem = (endbrk + 8191) & ~8191;
742 }
743
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
746 specified. */
747 if (abfd != NULL && !cris_bare_iron)
748 {
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
752 simulator. */
753 USI envtop = 0x40000000;
754 USI stacktop = 0x3e000000;
755 USI envstart;
756 int envc;
757 int len = strlen (name) + 1;
758 USI epp, epp0;
759 USI stacklen;
760 int i;
761 char **prog_argv = STATE_PROG_ARGV (sd);
762 int my_argc = 0;
763 USI csp;
764 bfd_byte buf[4];
765
766 /* Count in the environment as well. */
767 for (envc = 0; my_environ[envc] != NULL; envc++)
768 len += strlen (my_environ[envc]) + 1;
769
770 for (i = 0; prog_argv[i] != NULL; my_argc++, i++)
771 len += strlen (prog_argv[i]) + 1;
772
773 envstart = (envtop - len) & ~8191;
774
775 /* Create read-only block for the environment strings. */
776 sim_core_attach (sd, NULL, 0, access_read, 0,
777 envstart, (len + 8191) & ~8191,
778 0, NULL, NULL);
779
780 /* This shouldn't happen. */
781 if (envstart < stacktop)
782 stacktop = envstart - 64 * 8192;
783
784 csp = stacktop;
785
786 /* Note that the linux kernel does not correctly compute the storage
787 needs for the static-exe AUX vector. */
788
789 csp -= ARRAY_SIZE (auxv_entries) * 4 * 2;
790
791 csp -= (envc + 1) * 4;
792 csp -= (my_argc + 1) * 4;
793 csp -= 4;
794
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);
798
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
804 list). */
805 stack_low = (csp - (7168*1024)) & ~8191;
806
807 stacklen = stacktop - stack_low;
808
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,
812 stack_low, stacklen,
813 0, NULL, NULL);
814
815 epp = epp0 = envstart;
816
817 /* Can't use sim_core_write_unaligned_4 without everything
818 initialized when tracing, and then these writes would get into
819 the trace. */
820 #define write_dword(addr, data) \
821 do \
822 { \
823 USI data_ = data; \
824 USI addr_ = addr; \
825 bfd_putl32 (data_, buf); \
826 if (sim_core_write_buffer (sd, NULL, NULL_CIA, buf, addr_, 4) != 4)\
827 goto abandon_chip; \
828 } \
829 while (0)
830
831 write_dword (csp, my_argc);
832 csp += 4;
833
834 for (i = 0; i < my_argc; i++, csp += 4)
835 {
836 size_t strln = strlen (prog_argv[i]) + 1;
837
838 if (sim_core_write_buffer (sd, NULL, NULL_CIA, prog_argv[i], epp,
839 strln)
840 != strln)
841 goto abandon_chip;
842
843 write_dword (csp, envstart + epp - epp0);
844 epp += strln;
845 }
846
847 write_dword (csp, 0);
848 csp += 4;
849
850 for (i = 0; i < envc; i++, csp += 4)
851 {
852 unsigned int strln = strlen (my_environ[i]) + 1;
853
854 if (sim_core_write_buffer (sd, NULL, NULL_CIA, my_environ[i], epp,
855 strln)
856 != strln)
857 goto abandon_chip;
858
859 write_dword (csp, envstart + epp - epp0);
860 epp += strln;
861 }
862
863 write_dword (csp, 0);
864 csp += 4;
865
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
870 let's set it now. */
871 exec_load_addr = startmem;
872
873 if (!cris_handle_interpreter (sd, abfd))
874 goto abandon_chip;
875
876 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
877 for (i = 0; i < ARRAY_SIZE (auxv_entries); i++)
878 {
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);
884 csp += 4 + 4;
885 }
886 }
887
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%lx,0x%lx", startmem,
891 endmem - startmem);
892
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);
896
897 /* Establish any remaining configuration options. */
898 if (sim_config (sd) != SIM_RC_OK)
899 {
900 abandon_chip:
901 free_state (sd);
902 return 0;
903 }
904
905 if (sim_post_argv_init (sd) != SIM_RC_OK)
906 {
907 free_state (sd);
908 return 0;
909 }
910
911 /* Open a copy of the cpu descriptor table. */
912 {
913 CGEN_CPU_DESC cd = cris_cgen_cpu_open_1 (STATE_ARCHITECTURE (sd)->printable_name,
914 CGEN_ENDIAN_LITTLE);
915 for (i = 0; i < MAX_NR_PROCESSORS; ++i)
916 {
917 SIM_CPU *cpu = STATE_CPU (sd, i);
918 CPU_CPU_DESC (cpu) = cd;
919 CPU_DISASSEMBLER (cpu) = cris_disassemble_insn;
920
921 /* See cris_option_handler for the reason why this is needed. */
922 CPU_CRIS_MISC_PROFILE (cpu)->flags = STATE_TRACE_FLAGS (sd)[0];
923
924 /* Set SP to the stack we allocated above. */
925 (* CPU_REG_STORE (cpu)) (cpu, H_GR_SP, (char *) sp_init, 4);
926
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;
932 cpu->syscalls = 0;
933 cpu->m1threads = 0;
934 cpu->threadno = 0;
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;
940 #if WITH_HW
941 cpu->deliver_interrupt = NULL;
942 #endif
943 }
944 #if WITH_HW
945 /* Always be cycle-accurate and call before/after functions if
946 with-hardware. */
947 sim_profile_set_option (sd, "-model", PROFILE_MODEL_IDX, "on");
948 #endif
949 }
950
951 /* Initialize various cgen things not done by common framework.
952 Must be done after cris_cgen_cpu_open. */
953 cgen_init (sd);
954
955 cris_set_callbacks (callback);
956
957 return sd;
958 }
959
960 SIM_RC
sim_create_inferior(SIM_DESC sd,struct bfd * abfd,char * const * argv ATTRIBUTE_UNUSED,char * const * envp ATTRIBUTE_UNUSED)961 sim_create_inferior (SIM_DESC sd, struct bfd *abfd,
962 char * const *argv ATTRIBUTE_UNUSED,
963 char * const *envp ATTRIBUTE_UNUSED)
964 {
965 SIM_CPU *current_cpu = STATE_CPU (sd, 0);
966 SIM_ADDR addr;
967
968 if (sd != NULL)
969 addr = cris_start_address != (SIM_ADDR) -1
970 ? cris_start_address
971 : (interp_start_addr != 0
972 ? interp_start_addr
973 : bfd_get_start_address (abfd));
974 else
975 addr = 0;
976 sim_pc_set (current_cpu, addr);
977
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)
983 {
984 freeargv (STATE_PROG_ARGV (sd));
985 STATE_PROG_ARGV (sd) = dupargv (argv);
986 }
987
988 return SIM_RC_OK;
989 }
990
991 /* Disassemble an instruction. */
992
993 static void
cris_disassemble_insn(SIM_CPU * cpu,const CGEN_INSN * insn ATTRIBUTE_UNUSED,const ARGBUF * abuf ATTRIBUTE_UNUSED,IADDR pc,char * buf)994 cris_disassemble_insn (SIM_CPU *cpu,
995 const CGEN_INSN *insn ATTRIBUTE_UNUSED,
996 const ARGBUF *abuf ATTRIBUTE_UNUSED,
997 IADDR pc, char *buf)
998 {
999 disassembler_ftype pinsn;
1000 struct disassemble_info disasm_info;
1001 SFILE sfile;
1002 SIM_DESC sd = CPU_STATE (cpu);
1003
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);
1013 }
1014