1 /* Simulator for Analog Devices Blackfin processors.
3 Copyright (C) 2005-2015 Free Software Foundation, Inc.
4 Contributed by Analog Devices, Inc.
6 This file is part of simulators.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
32 #include "gdb/callback.h"
33 #include "gdb/signals.h"
37 #include "targ-vals.h"
39 /* The numbers here do not matter. They just need to be unique. */
40 #define CB_SYS_ioctl 201
41 #define CB_SYS_mmap2 202
42 #define CB_SYS_munmap 203
43 #define CB_SYS_dup2 204
44 #define CB_SYS_getuid 205
45 #define CB_SYS_getuid32 206
46 #define CB_SYS_getgid 207
47 #define CB_SYS_getgid32 208
48 #define CB_SYS_setuid 209
49 #define CB_SYS_setuid32 210
50 #define CB_SYS_setgid 211
51 #define CB_SYS_setgid32 212
52 #define CB_SYS_pread 213
53 #define CB_SYS__llseek 214
54 #define CB_SYS_getcwd 215
55 #define CB_SYS_stat64 216
56 #define CB_SYS_lstat64 217
57 #define CB_SYS_fstat64 218
58 #define CB_SYS_ftruncate64 219
59 #define CB_SYS_gettimeofday 220
60 #define CB_SYS_access 221
61 #include "linux-targ-map.h"
62 #include "linux-fixed-code.h"
64 #include "elf/common.h"
65 #include "elf/external.h"
66 #include "elf/internal.h"
70 #include "dv-bfin_cec.h"
71 #include "dv-bfin_mmu.h"
86 # define setuid(uid) -1
89 # define setgid(gid) -1
92 static const char cb_linux_stat_map_32[] =
93 /* Linux kernel 32bit layout: */
94 "st_dev,2:space,2:st_ino,4:st_mode,2:st_nlink,2:st_uid,2:st_gid,2:st_rdev,2:"
95 "space,2:st_size,4:st_blksize,4:st_blocks,4:st_atime,4:st_atimensec,4:"
96 "st_mtime,4:st_mtimensec,4:st_ctime,4:st_ctimensec,4:space,4:space,4";
97 /* uClibc public ABI 32bit layout:
98 "st_dev,8:space,2:space,2:st_ino,4:st_mode,4:st_nlink,4:st_uid,4:st_gid,4:"
99 "st_rdev,8:space,2:space,2:st_size,4:st_blksiez,4:st_blocks,4:st_atime,4:"
100 "st_atimensec,4:st_mtime,4:st_mtimensec,4:st_ctime,4:st_ctimensec,4:space,4:"
102 static const char cb_linux_stat_map_64[] =
103 "st_dev,8:space,4:space,4:st_mode,4:st_nlink,4:st_uid,4:st_gid,4:st_rdev,8:"
104 "space,4:st_size,8:st_blksize,4:st_blocks,8:st_atime,4:st_atimensec,4:"
105 "st_mtime,4:st_mtimensec,4:st_ctime,4:st_ctimensec,4:st_ino,8";
106 static const char cb_libgloss_stat_map_32[] =
107 "st_dev,2:st_ino,2:st_mode,4:st_nlink,2:st_uid,2:st_gid,2:st_rdev,2:"
108 "st_size,4:st_atime,4:space,4:st_mtime,4:space,4:st_ctime,4:"
109 "space,4:st_blksize,4:st_blocks,4:space,8";
110 static const char *stat_map_32, *stat_map_64;
112 /* Count the number of arguments in an argv. */
114 count_argc (const char * const *argv)
121 for (i = 0; argv[i] != NULL; ++i)
126 /* Read/write functions for system call interface. */
129 syscall_read_mem (host_callback *cb, struct cb_syscall *sc,
130 unsigned long taddr, char *buf, int bytes)
132 SIM_DESC sd = (SIM_DESC) sc->p1;
133 SIM_CPU *cpu = (SIM_CPU *) sc->p2;
135 MAYBE_TRACE (CORE, cpu, "DBUS FETCH (syscall) %i bytes @ 0x%08lx", bytes, taddr);
137 return sim_core_read_buffer (sd, cpu, read_map, buf, taddr, bytes);
141 syscall_write_mem (host_callback *cb, struct cb_syscall *sc,
142 unsigned long taddr, const char *buf, int bytes)
144 SIM_DESC sd = (SIM_DESC) sc->p1;
145 SIM_CPU *cpu = (SIM_CPU *) sc->p2;
147 MAYBE_TRACE (CORE, cpu, "DBUS STORE (syscall) %i bytes @ 0x%08lx", bytes, taddr);
149 return sim_core_write_buffer (sd, cpu, write_map, buf, taddr, bytes);
152 /* Simulate a monitor trap, put the result into r0 and errno into r1
153 return offset by which to adjust pc. */
156 bfin_syscall (SIM_CPU *cpu)
158 SIM_DESC sd = CPU_STATE (cpu);
159 const char * const *argv = (void *)STATE_PROG_ARGV (sd);
160 host_callback *cb = STATE_CALLBACK (sd);
164 char _tbuf[1024 * 3], *tbuf = _tbuf, tstr[1024];
167 CB_SYSCALL_INIT (&sc);
169 if (STATE_ENVIRONMENT (sd) == USER_ENVIRONMENT)
173 sc.arg1 = args[0] = DREG (0);
174 sc.arg2 = args[1] = DREG (1);
175 sc.arg3 = args[2] = DREG (2);
176 sc.arg4 = args[3] = DREG (3);
177 /*sc.arg5 =*/ args[4] = DREG (4);
178 /*sc.arg6 =*/ args[5] = DREG (5);
182 /* libgloss syscall. */
184 sc.arg1 = args[0] = GET_LONG (DREG (0));
185 sc.arg2 = args[1] = GET_LONG (DREG (0) + 4);
186 sc.arg3 = args[2] = GET_LONG (DREG (0) + 8);
187 sc.arg4 = args[3] = GET_LONG (DREG (0) + 12);
188 /*sc.arg5 =*/ args[4] = GET_LONG (DREG (0) + 16);
189 /*sc.arg6 =*/ args[5] = GET_LONG (DREG (0) + 20);
193 sc.read_mem = syscall_read_mem;
194 sc.write_mem = syscall_write_mem;
196 /* Common cb_syscall() handles most functions. */
197 switch (cb_target_to_host_syscall (cb, sc.func))
200 tbuf += sprintf (tbuf, "exit(%i)", args[0]);
201 sim_engine_halt (sd, cpu, NULL, PCREG, sim_exited, sc.arg1);
205 tbuf += sprintf (tbuf, "argc()");
206 sc.result = count_argc (argv);
210 tbuf += sprintf (tbuf, "argnlen(%u)", args[0]);
211 if (sc.arg1 < count_argc (argv))
212 sc.result = strlen (argv[sc.arg1]);
219 tbuf += sprintf (tbuf, "argn(%u)", args[0]);
220 if (sc.arg1 < count_argc (argv))
222 const char *argn = argv[sc.arg1];
223 int len = strlen (argn);
224 int written = sc.write_mem (cb, &sc, sc.arg2, argn, len + 1);
225 if (written == len + 1)
236 case CB_SYS_gettimeofday:
238 struct timeval _tv, *tv = &_tv;
239 struct timezone _tz, *tz = &_tz;
241 tbuf += sprintf (tbuf, "gettimeofday(%#x, %#x)", args[0], args[1]);
247 sc.result = gettimeofday (tv, tz);
256 sc.write_mem (cb, &sc, sc.arg1, (void *)&t, 4);
258 sc.write_mem (cb, &sc, sc.arg1 + 4, (void *)&t, 4);
263 t = tz->tz_minuteswest;
264 sc.write_mem (cb, &sc, sc.arg1, (void *)&t, 4);
266 sc.write_mem (cb, &sc, sc.arg1 + 4, (void *)&t, 4);
275 /* XXX: hack just enough to get basic stdio w/uClibc ... */
276 tbuf += sprintf (tbuf, "ioctl(%i, %#x, %u)", args[0], args[1], args[2]);
277 if (sc.arg2 == 0x5401)
279 sc.result = !isatty (sc.arg1);
285 sc.errcode = TARGET_EINVAL;
291 static bu32 heap = BFIN_DEFAULT_MEM_SIZE / 2;
294 tbuf += sprintf (tbuf, "mmap2(%#x, %u, %#x, %#x, %i, %u)",
295 args[0], args[1], args[2], args[3], args[4], args[5]);
299 if (sc.arg4 & 0x20 /*MAP_ANONYMOUS*/)
300 /* XXX: We don't handle zeroing, but default is all zeros. */;
301 else if (args[4] >= MAX_CALLBACK_FDS)
302 sc.errcode = TARGET_ENOSYS;
306 char *data = xmalloc (sc.arg2);
308 /* XXX: Should add a cb->pread. */
309 if (pread (cb->fdmap[args[4]], data, sc.arg2, args[5] << 12) == sc.arg2)
310 sc.write_mem (cb, &sc, heap, data, sc.arg2);
312 sc.errcode = TARGET_EINVAL;
316 sc.errcode = TARGET_ENOSYS;
328 /* Keep it page aligned. */
329 heap = ALIGN (heap, 4096);
335 /* XXX: meh, just lie for mmap(). */
336 tbuf += sprintf (tbuf, "munmap(%#x, %u)", args[0], args[1]);
341 tbuf += sprintf (tbuf, "dup2(%i, %i)", args[0], args[1]);
342 if (sc.arg1 >= MAX_CALLBACK_FDS || sc.arg2 >= MAX_CALLBACK_FDS)
345 sc.errcode = TARGET_EINVAL;
349 sc.result = dup2 (cb->fdmap[sc.arg1], cb->fdmap[sc.arg2]);
355 tbuf += sprintf (tbuf, "llseek(%i, %u, %u, %#x, %u)",
356 args[0], args[1], args[2], args[3], args[4]);
357 sc.func = TARGET_LINUX_SYS_lseek;
361 sc.errcode = TARGET_EINVAL;
367 cb_syscall (cb, &sc);
371 sc.write_mem (cb, &sc, args[3], (void *)&sc.result, 4);
372 sc.write_mem (cb, &sc, args[3] + 4, (void *)&z, 4);
377 /* XXX: Should add a cb->pread. */
379 tbuf += sprintf (tbuf, "pread(%i, %#x, %u, %i)",
380 args[0], args[1], args[2], args[3]);
381 if (sc.arg1 >= MAX_CALLBACK_FDS)
384 sc.errcode = TARGET_EINVAL;
388 long old_pos, read_result, read_errcode;
390 /* Get current filepos. */
391 sc.func = TARGET_LINUX_SYS_lseek;
394 cb_syscall (cb, &sc);
399 /* Move to the new pos. */
400 sc.func = TARGET_LINUX_SYS_lseek;
403 cb_syscall (cb, &sc);
408 sc.func = TARGET_LINUX_SYS_read;
411 cb_syscall (cb, &sc);
412 read_result = sc.result;
413 read_errcode = sc.errcode;
415 /* Move back to the old pos. */
416 sc.func = TARGET_LINUX_SYS_lseek;
419 cb_syscall (cb, &sc);
421 sc.result = read_result;
422 sc.errcode = read_errcode;
427 tbuf += sprintf (tbuf, "getcwd(%#x, %u)", args[0], args[1]);
429 p = alloca (sc.arg2);
430 if (getcwd (p, sc.arg2) == NULL)
433 sc.errcode = TARGET_EINVAL;
437 sc.write_mem (cb, &sc, sc.arg1, p, sc.arg2);
443 if (cb_get_string (cb, &sc, tstr, sizeof (tstr), args[0]))
444 strcpy (tstr, "???");
445 tbuf += sprintf (tbuf, "stat64(%#x:\"%s\", %u)", args[0], tstr, args[1]);
446 cb->stat_map = stat_map_64;
447 sc.func = TARGET_LINUX_SYS_stat;
448 cb_syscall (cb, &sc);
449 cb->stat_map = stat_map_32;
452 if (cb_get_string (cb, &sc, tstr, sizeof (tstr), args[0]))
453 strcpy (tstr, "???");
454 tbuf += sprintf (tbuf, "lstat64(%#x:\"%s\", %u)", args[0], tstr, args[1]);
455 cb->stat_map = stat_map_64;
456 sc.func = TARGET_LINUX_SYS_lstat;
457 cb_syscall (cb, &sc);
458 cb->stat_map = stat_map_32;
461 tbuf += sprintf (tbuf, "fstat64(%#x, %u)", args[0], args[1]);
462 cb->stat_map = stat_map_64;
463 sc.func = TARGET_LINUX_SYS_fstat;
464 cb_syscall (cb, &sc);
465 cb->stat_map = stat_map_32;
468 case CB_SYS_ftruncate64:
469 tbuf += sprintf (tbuf, "ftruncate64(%u, %u)", args[0], args[1]);
470 sc.func = TARGET_LINUX_SYS_ftruncate;
471 cb_syscall (cb, &sc);
475 case CB_SYS_getuid32:
476 tbuf += sprintf (tbuf, "getuid()");
477 sc.result = getuid ();
480 case CB_SYS_getgid32:
481 tbuf += sprintf (tbuf, "getgid()");
482 sc.result = getgid ();
486 case CB_SYS_setuid32:
487 tbuf += sprintf (tbuf, "setuid(%u)", args[0]);
488 sc.result = setuid (sc.arg1);
492 case CB_SYS_setgid32:
493 tbuf += sprintf (tbuf, "setgid(%u)", args[0]);
494 sc.result = setgid (sc.arg1);
498 tbuf += sprintf (tbuf, "getpid()");
499 sc.result = getpid ();
502 tbuf += sprintf (tbuf, "kill(%u, %i)", args[0], args[1]);
503 /* Only let the app kill itself. */
504 if (sc.arg1 != getpid ())
507 sc.errcode = TARGET_EPERM;
512 sc.result = kill (sc.arg1, sc.arg2);
516 sc.errcode = TARGET_ENOSYS;
522 if (cb_get_string (cb, &sc, tstr, sizeof (tstr), args[0]))
523 strcpy (tstr, "???");
524 tbuf += sprintf (tbuf, "open(%#x:\"%s\", %#x, %o)",
525 args[0], tstr, args[1], args[2]);
528 tbuf += sprintf (tbuf, "close(%i)", args[0]);
531 tbuf += sprintf (tbuf, "read(%i, %#x, %u)", args[0], args[1], args[2]);
534 if (cb_get_string (cb, &sc, tstr, sizeof (tstr), args[1]))
535 strcpy (tstr, "???");
536 tbuf += sprintf (tbuf, "write(%i, %#x:\"%s\", %u)",
537 args[0], args[1], tstr, args[2]);
540 tbuf += sprintf (tbuf, "lseek(%i, %i, %i)", args[0], args[1], args[2]);
543 if (cb_get_string (cb, &sc, tstr, sizeof (tstr), args[0]))
544 strcpy (tstr, "???");
545 tbuf += sprintf (tbuf, "unlink(%#x:\"%s\")", args[0], tstr);
547 case CB_SYS_truncate:
548 if (cb_get_string (cb, &sc, tstr, sizeof (tstr), args[0]))
549 strcpy (tstr, "???");
550 tbuf += sprintf (tbuf, "truncate(%#x:\"%s\", %i)", args[0], tstr, args[1]);
552 case CB_SYS_ftruncate:
553 tbuf += sprintf (tbuf, "ftruncate(%i, %i)", args[0], args[1]);
556 if (cb_get_string (cb, &sc, tstr, sizeof (tstr), args[0]))
557 strcpy (tstr, "???");
558 tbuf += sprintf (tbuf, "rename(%#x:\"%s\", ", args[0], tstr);
559 if (cb_get_string (cb, &sc, tstr, sizeof (tstr), args[1]))
560 strcpy (tstr, "???");
561 tbuf += sprintf (tbuf, "%#x:\"%s\")", args[1], tstr);
564 if (cb_get_string (cb, &sc, tstr, sizeof (tstr), args[0]))
565 strcpy (tstr, "???");
566 tbuf += sprintf (tbuf, "stat(%#x:\"%s\", %#x)", args[0], tstr, args[1]);
569 tbuf += sprintf (tbuf, "fstat(%i, %#x)", args[0], args[1]);
572 if (cb_get_string (cb, &sc, tstr, sizeof (tstr), args[0]))
573 strcpy (tstr, "???");
574 tbuf += sprintf (tbuf, "lstat(%#x:\"%s\", %#x)", args[0], tstr, args[1]);
577 tbuf += sprintf (tbuf, "pipe(%#x, %#x)", args[0], args[1]);
581 tbuf += sprintf (tbuf, "???_%i(%#x, %#x, %#x, %#x, %#x, %#x)", sc.func,
582 args[0], args[1], args[2], args[3], args[4], args[5]);
584 cb_syscall (cb, &sc);
590 cb->last_errno = errno;
591 sc.errcode = cb->get_errno (cb);
595 TRACE_EVENTS (cpu, "syscall_%i(%#x, %#x, %#x, %#x, %#x, %#x) = %li (error = %i)",
596 sc.func, args[0], args[1], args[2], args[3], args[4], args[5],
597 sc.result, sc.errcode);
599 tbuf += sprintf (tbuf, " = ");
600 if (STATE_ENVIRONMENT (sd) == USER_ENVIRONMENT)
604 tbuf += sprintf (tbuf, "-1 (error = %i)", sc.errcode);
605 if (sc.errcode == cb_host_to_target_errno (cb, ENOSYS))
607 sim_io_eprintf (sd, "bfin-sim: %#x: unimplemented syscall %i\n",
610 SET_DREG (0, -sc.errcode);
615 tbuf += sprintf (tbuf, "%#lx", sc.result);
617 tbuf += sprintf (tbuf, "%lu", sc.result);
618 SET_DREG (0, sc.result);
623 tbuf += sprintf (tbuf, "%lu (error = %i)", sc.result, sc.errcode);
624 SET_DREG (0, sc.result);
625 SET_DREG (1, sc.result2);
626 SET_DREG (2, sc.errcode);
629 TRACE_SYSCALL (cpu, "%s", _tbuf);
633 trace_register (SIM_DESC sd,
639 trace_printf (sd, cpu, "%s %s",
641 TRACE_PREFIX (CPU_TRACE_DATA (cpu)));
643 trace_vprintf (sd, cpu, fmt, ap);
645 trace_printf (sd, cpu, "\n");
648 /* Execute a single instruction. */
651 step_once (SIM_CPU *cpu)
653 SIM_DESC sd = CPU_STATE (cpu);
654 bu32 insn_len, oldpc = PCREG;
658 if (TRACE_ANY_P (cpu))
659 trace_prefix (sd, cpu, NULL_CIA, oldpc, TRACE_LINENUM_P (cpu),
660 NULL, 0, " "); /* Use a space for gcc warnings. */
662 /* Handle hardware single stepping when lower than EVT3, and when SYSCFG
663 has already had the SSSTEP bit enabled. */
665 if (STATE_ENVIRONMENT (sd) == OPERATING_ENVIRONMENT
666 && (SYSCFGREG & SYSCFG_SSSTEP))
668 int ivg = cec_get_ivg (cpu);
669 if (ivg == -1 || ivg > 3)
674 /* XXX: Is this what happens on the hardware ? */
675 if (cec_get_ivg (cpu) == EVT_EMU)
676 cec_return (cpu, EVT_EMU);
679 BFIN_CPU_STATE.did_jump = false;
681 insn_len = interp_insn_bfin (cpu, oldpc);
683 /* If we executed this insn successfully, then we always decrement
684 the loop counter. We don't want to update the PC though if the
685 last insn happened to be a change in code flow (jump/etc...). */
686 if (!BFIN_CPU_STATE.did_jump)
687 SET_PCREG (hwloop_get_next_pc (cpu, oldpc, insn_len));
688 for (i = 1; i >= 0; --i)
689 if (LCREG (i) && oldpc == LBREG (i))
691 SET_LCREG (i, LCREG (i) - 1);
696 ++ PROFILE_TOTAL_INSN_COUNT (CPU_PROFILE_DATA (cpu));
698 /* Handle hardware single stepping only if we're still lower than EVT3.
699 XXX: May not be entirely correct wrt EXCPT insns. */
702 int ivg = cec_get_ivg (cpu);
703 if (ivg == -1 || ivg > 3)
706 cec_exception (cpu, VEC_STEP);
714 sim_engine_run (SIM_DESC sd,
715 int next_cpu_nr, /* ignore */
716 int nr_cpus, /* ignore */
717 int siggnal) /* ignore */
722 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
724 cpu = STATE_CPU (sd, 0);
729 /* Process any events -- can't use tickn because it may
730 advance right over the next event. */
731 for (ticks = 0; ticks < CYCLE_DELAY; ++ticks)
732 if (sim_events_tick (sd))
733 sim_events_process (sd);
737 /* Cover function of sim_state_free to free the cpu buffers as well. */
740 free_state (SIM_DESC sd)
742 if (STATE_MODULES (sd) != NULL)
743 sim_module_uninstall (sd);
744 sim_cpu_free_all (sd);
748 /* Create an instance of the simulator. */
751 bfin_initialize_cpu (SIM_DESC sd, SIM_CPU *cpu)
753 memset (&cpu->state, 0, sizeof (cpu->state));
755 PROFILE_TOTAL_INSN_COUNT (CPU_PROFILE_DATA (cpu)) = 0;
757 bfin_model_cpu_init (sd, cpu);
759 /* Set default stack to top of scratch pad. */
760 SET_SPREG (BFIN_DEFAULT_MEM_SIZE);
761 SET_KSPREG (BFIN_DEFAULT_MEM_SIZE);
762 SET_USPREG (BFIN_DEFAULT_MEM_SIZE);
764 /* This is what the hardware likes. */
765 SET_SYSCFGREG (0x30);
769 sim_open (SIM_OPEN_KIND kind, host_callback *callback,
770 struct bfd *abfd, char **argv)
774 SIM_DESC sd = sim_state_alloc (kind, callback);
776 /* The cpu data is kept in a separately allocated chunk of memory. */
777 if (sim_cpu_alloc_all (sd, 1, /*cgen_cpu_max_extra_bytes ()*/0) != SIM_RC_OK)
784 /* XXX: Only first core gets profiled ? */
785 SIM_CPU *cpu = STATE_CPU (sd, 0);
786 STATE_WATCHPOINTS (sd)->pc = &PCREG;
787 STATE_WATCHPOINTS (sd)->sizeof_pc = sizeof (PCREG);
790 if (sim_pre_argv_init (sd, argv[0]) != SIM_RC_OK)
796 /* XXX: Default to the Virtual environment. */
797 if (STATE_ENVIRONMENT (sd) == ALL_ENVIRONMENT)
798 STATE_ENVIRONMENT (sd) = VIRTUAL_ENVIRONMENT;
800 /* These options override any module options.
801 Obviously ambiguity should be avoided, however the caller may wish to
802 augment the meaning of an option. */
803 #define e_sim_add_option_table(sd, options) \
805 extern const OPTION options[]; \
806 sim_add_option_table (sd, NULL, options); \
808 e_sim_add_option_table (sd, bfin_mmu_options);
809 e_sim_add_option_table (sd, bfin_mach_options);
811 /* getopt will print the error message so we just have to exit if this fails.
812 FIXME: Hmmm... in the case of gdb we need getopt to call
814 if (sim_parse_args (sd, argv) != SIM_RC_OK)
820 /* Allocate external memory if none specified by user.
821 Use address 4 here in case the user wanted address 0 unmapped. */
822 if (sim_core_read_buffer (sd, NULL, read_map, &c, 4, 1) == 0)
824 bu16 emuexcpt = 0x25;
825 sim_do_commandf (sd, "memory-size 0x%lx", BFIN_DEFAULT_MEM_SIZE);
826 sim_write (sd, 0, (void *)&emuexcpt, 2);
829 /* Check for/establish the a reference program image. */
830 if (sim_analyze_program (sd,
831 (STATE_PROG_ARGV (sd) != NULL
832 ? *STATE_PROG_ARGV (sd)
833 : NULL), abfd) != SIM_RC_OK)
839 /* Establish any remaining configuration options. */
840 if (sim_config (sd) != SIM_RC_OK)
846 if (sim_post_argv_init (sd) != SIM_RC_OK)
852 /* CPU specific initialization. */
853 for (i = 0; i < MAX_NR_PROCESSORS; ++i)
855 SIM_CPU *cpu = STATE_CPU (sd, i);
856 bfin_initialize_cpu (sd, cpu);
863 sim_close (SIM_DESC sd, int quitting)
865 sim_module_uninstall (sd);
868 /* Some utils don't like having a NULL environ. */
869 static const char * const simple_env[] = { "HOME=/", "PATH=/bin", NULL };
871 static bu32 fdpic_load_offset;
874 bfin_fdpic_load (SIM_DESC sd, SIM_CPU *cpu, struct bfd *abfd, bu32 *sp,
875 bu32 *elf_addrs, char **ldso_path)
880 Elf_Internal_Ehdr *iehdr;
881 Elf32_External_Ehdr ehdr;
882 Elf_Internal_Phdr *phdrs;
890 unsigned char null[4] = { 0, 0, 0, 0 };
895 /* See if this an FDPIC ELF. */
898 goto skip_fdpic_init;
899 if (bfd_seek (abfd, 0, SEEK_SET) != 0)
900 goto skip_fdpic_init;
901 if (bfd_bread (&ehdr, sizeof (ehdr), abfd) != sizeof (ehdr))
902 goto skip_fdpic_init;
903 iehdr = elf_elfheader (abfd);
904 if (!(iehdr->e_flags & EF_BFIN_FDPIC))
905 goto skip_fdpic_init;
907 if (STATE_OPEN_KIND (sd) == SIM_OPEN_DEBUG)
908 sim_io_printf (sd, "Loading FDPIC ELF %s\n Load base: %#x\n ELF entry: %#x\n",
909 bfd_get_filename (abfd), fdpic_load_offset, elf_addrs[0]);
911 /* Grab the Program Headers to set up the loadsegs on the stack. */
912 phdr_size = bfd_get_elf_phdr_upper_bound (abfd);
914 goto skip_fdpic_init;
915 phdrs = xmalloc (phdr_size);
916 phdrc = bfd_get_elf_phdrs (abfd, phdrs);
918 goto skip_fdpic_init;
920 /* Push the Ehdr onto the stack. */
921 *sp -= sizeof (ehdr);
923 sim_write (sd, *sp, (void *)&ehdr, sizeof (ehdr));
924 if (STATE_OPEN_KIND (sd) == SIM_OPEN_DEBUG)
925 sim_io_printf (sd, " Elf_Ehdr: %#x\n", *sp);
927 /* Since we're relocating things ourselves, we need to relocate
928 the start address as well. */
929 elf_addrs[0] = bfd_get_start_address (abfd) + fdpic_load_offset;
931 /* And the Exec's Phdrs onto the stack. */
932 if (STATE_PROG_BFD (sd) == abfd)
934 elf_addrs[4] = elf_addrs[0];
936 phdr_size = iehdr->e_phentsize * iehdr->e_phnum;
937 if (bfd_seek (abfd, iehdr->e_phoff, SEEK_SET) != 0)
938 goto skip_fdpic_init;
939 data = xmalloc (phdr_size);
940 if (bfd_bread (data, phdr_size, abfd) != phdr_size)
941 goto skip_fdpic_init;
944 elf_addrs[2] = phdrc;
945 sim_write (sd, *sp, data, phdr_size);
947 if (STATE_OPEN_KIND (sd) == SIM_OPEN_DEBUG)
948 sim_io_printf (sd, " Elf_Phdrs: %#x\n", *sp);
951 /* Now push all the loadsegs. */
954 for (i = phdrc; i >= 0; --i)
955 if (phdrs[i].p_type == PT_LOAD)
957 Elf_Internal_Phdr *p = &phdrs[i];
958 bu32 paddr, vaddr, memsz, filesz;
960 paddr = p->p_paddr + fdpic_load_offset;
963 filesz = p->p_filesz;
965 if (STATE_OPEN_KIND (sd) == SIM_OPEN_DEBUG)
966 sim_io_printf (sd, " PHDR %i: vma %#x lma %#x filesz %#x memsz %#x\n",
967 i, vaddr, paddr, filesz, memsz);
969 data = xmalloc (memsz);
971 memset (data + filesz, 0, memsz - filesz);
973 if (bfd_seek (abfd, p->p_offset, SEEK_SET) == 0
974 && bfd_bread (data, filesz, abfd) == filesz)
975 sim_write (sd, paddr, data, memsz);
979 max_load_addr = MAX (paddr + memsz, max_load_addr);
982 sim_write (sd, *sp+0, (void *)&paddr, 4); /* loadseg.addr */
983 sim_write (sd, *sp+4, (void *)&vaddr, 4); /* loadseg.p_vaddr */
984 sim_write (sd, *sp+8, (void *)&memsz, 4); /* loadseg.p_memsz */
987 else if (phdrs[i].p_type == PT_DYNAMIC)
989 elf_addrs[5] = phdrs[i].p_paddr + fdpic_load_offset;
990 if (STATE_OPEN_KIND (sd) == SIM_OPEN_DEBUG)
991 sim_io_printf (sd, " PT_DYNAMIC: %#x\n", elf_addrs[5]);
993 else if (phdrs[i].p_type == PT_INTERP)
995 uint32_t off = phdrs[i].p_offset;
996 uint32_t len = phdrs[i].p_filesz;
998 *ldso_path = xmalloc (len);
999 if (bfd_seek (abfd, off, SEEK_SET) != 0
1000 || bfd_bread (*ldso_path, len, abfd) != len)
1005 else if (STATE_OPEN_KIND (sd) == SIM_OPEN_DEBUG)
1006 sim_io_printf (sd, " PT_INTERP: %s\n", *ldso_path);
1009 /* Update the load offset with a few extra pages. */
1010 fdpic_load_offset = ALIGN (MAX (max_load_addr, fdpic_load_offset), 0x10000);
1011 fdpic_load_offset += 0x10000;
1013 /* Push the summary loadmap info onto the stack last. */
1015 sim_write (sd, *sp+0, null, 2); /* loadmap.version */
1016 sim_write (sd, *sp+2, (void *)&nsegs, 2); /* loadmap.nsegs */
1026 bfin_user_init (SIM_DESC sd, SIM_CPU *cpu, struct bfd *abfd,
1027 const char * const *argv, const char * const *env)
1029 /* XXX: Missing host -> target endian ... */
1030 /* Linux starts the user app with the stack:
1032 argv[0] -- pointers to the actual strings
1038 auxvt[0].type -- ELF Auxiliary Vector Table
1043 argv[0..N][0..M] -- actual argv/env strings
1045 FDPIC loadmaps -- for FDPIC apps
1046 So set things up the same way. */
1048 bu32 argv_flat, env_flat;
1052 /* start, at_phdr, at_phnum, at_base, at_entry, pt_dynamic */
1055 bu32 exec_loadmap, ldso_loadmap;
1058 unsigned char null[4] = { 0, 0, 0, 0 };
1060 host_callback *cb = STATE_CALLBACK (sd);
1062 elf_addrs[0] = elf_addrs[4] = bfd_get_start_address (abfd);
1063 elf_addrs[1] = elf_addrs[2] = elf_addrs[3] = elf_addrs[5] = 0;
1065 /* Keep the load addresses consistent between runs. Also make sure we make
1066 space for the fixed code region (part of the Blackfin Linux ABI). */
1067 fdpic_load_offset = 0x1000;
1069 /* First try to load this as an FDPIC executable. */
1071 if (!bfin_fdpic_load (sd, cpu, STATE_PROG_BFD (sd), &sp, elf_addrs, &ldso_path))
1072 goto skip_fdpic_init;
1075 /* If that worked, then load the fixed code region. We only do this for
1076 FDPIC ELFs atm because they are PIEs and let us relocate them without
1077 manual fixups. FLAT files however require location processing which
1078 we do not do ourselves, and they link with a VMA of 0. */
1079 sim_write (sd, 0x400, bfin_linux_fixed_code, sizeof (bfin_linux_fixed_code));
1081 /* If the FDPIC needs an interpreter, then load it up too. */
1084 const char *ldso_full_path = concat (simulator_sysroot, ldso_path, NULL);
1085 struct bfd *ldso_bfd;
1087 ldso_bfd = bfd_openr (ldso_full_path, STATE_TARGET (sd));
1090 sim_io_eprintf (sd, "bfin-sim: bfd open failed: %s\n", ldso_full_path);
1093 if (!bfd_check_format (ldso_bfd, bfd_object))
1094 sim_io_eprintf (sd, "bfin-sim: bfd format not valid: %s\n", ldso_full_path);
1095 bfd_set_arch_info (ldso_bfd, STATE_ARCHITECTURE (sd));
1097 if (!bfin_fdpic_load (sd, cpu, ldso_bfd, &sp, elf_addrs, &ldso_path))
1098 sim_io_eprintf (sd, "bfin-sim: FDPIC ldso failed to load: %s\n", ldso_full_path);
1100 sim_io_eprintf (sd, "bfin-sim: FDPIC ldso (%s) needs an interpreter (%s) !?\n",
1101 ldso_full_path, ldso_path);
1109 /* Finally setup the registers required by the FDPIC ABI. */
1110 SET_DREG (7, 0); /* Zero out FINI funcptr -- ldso will set this up. */
1111 SET_PREG (0, exec_loadmap); /* Exec loadmap addr. */
1112 SET_PREG (1, ldso_loadmap); /* Interp loadmap addr. */
1113 SET_PREG (2, elf_addrs[5]); /* PT_DYNAMIC map addr. */
1118 sim_pc_set (cpu, elf_addrs[0]);
1120 /* Figure out how much storage the argv/env strings need. */
1121 argc = count_argc (argv);
1124 argv_flat = argc; /* NUL bytes */
1125 for (i = 0; i < argc; ++i)
1126 argv_flat += strlen (argv[i]);
1130 envc = count_argc (env);
1131 env_flat = envc; /* NUL bytes */
1132 for (i = 0; i < envc; ++i)
1133 env_flat += strlen (env[i]);
1135 /* Push the Auxiliary Vector Table between argv/env and actual strings. */
1136 sp_flat = sp = ALIGN (SPREG - argv_flat - env_flat - 4, 4);
1139 # define AT_PUSH(at, val) \
1143 sim_write (sd, sp, (void *)&auxvt, 4); \
1146 sim_write (sd, sp, (void *)&auxvt, 4)
1147 unsigned int egid = getegid (), gid = getgid ();
1148 unsigned int euid = geteuid (), uid = getuid ();
1149 bu32 auxvt_size = 0;
1150 AT_PUSH (AT_NULL, 0);
1151 AT_PUSH (AT_SECURE, egid != gid || euid != uid);
1152 AT_PUSH (AT_EGID, egid);
1153 AT_PUSH (AT_GID, gid);
1154 AT_PUSH (AT_EUID, euid);
1155 AT_PUSH (AT_UID, uid);
1156 AT_PUSH (AT_ENTRY, elf_addrs[4]);
1157 AT_PUSH (AT_FLAGS, 0);
1158 AT_PUSH (AT_BASE, elf_addrs[3]);
1159 AT_PUSH (AT_PHNUM, elf_addrs[2]);
1160 AT_PUSH (AT_PHENT, sizeof (Elf32_External_Phdr));
1161 AT_PUSH (AT_PHDR, elf_addrs[1]);
1162 AT_PUSH (AT_CLKTCK, 100); /* XXX: This ever not 100 ? */
1163 AT_PUSH (AT_PAGESZ, 4096);
1164 AT_PUSH (AT_HWCAP, 0);
1169 /* Push the argc/argv/env after the auxvt. */
1170 sp -= ((1 + argc + 1 + envc + 1) * 4);
1173 /* First push the argc value. */
1174 sim_write (sd, sp, (void *)&argc, 4);
1177 /* Then the actual argv strings so we know where to point argv[]. */
1178 for (i = 0; i < argc; ++i)
1180 unsigned len = strlen (argv[i]) + 1;
1181 sim_write (sd, sp_flat, (void *)argv[i], len);
1182 sim_write (sd, sp, (void *)&sp_flat, 4);
1186 sim_write (sd, sp, null, 4);
1189 /* Then the actual env strings so we know where to point env[]. */
1190 for (i = 0; i < envc; ++i)
1192 unsigned len = strlen (env[i]) + 1;
1193 sim_write (sd, sp_flat, (void *)env[i], len);
1194 sim_write (sd, sp, (void *)&sp_flat, 4);
1199 /* Set some callbacks. */
1200 cb->syscall_map = cb_linux_syscall_map;
1201 cb->errno_map = cb_linux_errno_map;
1202 cb->open_map = cb_linux_open_map;
1203 cb->signal_map = cb_linux_signal_map;
1204 cb->stat_map = stat_map_32 = cb_linux_stat_map_32;
1205 stat_map_64 = cb_linux_stat_map_64;
1209 bfin_os_init (SIM_DESC sd, SIM_CPU *cpu, const char * const *argv)
1211 /* Pass the command line via a string in R0 like Linux expects. */
1214 bu32 cmdline = BFIN_L1_SRAM_SCRATCH;
1216 SET_DREG (0, cmdline);
1217 if (argv && argv[0])
1223 bu32 len = strlen (argv[i]);
1224 sim_write (sd, cmdline, (void *)argv[i], len);
1226 sim_write (sd, cmdline, &byte, 1);
1232 sim_write (sd, cmdline, &byte, 1);
1236 bfin_virtual_init (SIM_DESC sd, SIM_CPU *cpu)
1238 host_callback *cb = STATE_CALLBACK (sd);
1240 cb->stat_map = stat_map_32 = cb_libgloss_stat_map_32;
1245 sim_create_inferior (SIM_DESC sd, struct bfd *abfd,
1246 char **argv, char **env)
1248 SIM_CPU *cpu = STATE_CPU (sd, 0);
1253 addr = bfd_get_start_address (abfd);
1256 sim_pc_set (cpu, addr);
1258 /* Standalone mode (i.e. `bfin-...-run`) will take care of the argv
1259 for us in sim_open() -> sim_parse_args(). But in debug mode (i.e.
1260 'target sim' with `bfin-...-gdb`), we need to handle it. */
1261 if (STATE_OPEN_KIND (sd) == SIM_OPEN_DEBUG)
1263 freeargv (STATE_PROG_ARGV (sd));
1264 STATE_PROG_ARGV (sd) = dupargv (argv);
1267 switch (STATE_ENVIRONMENT (sd))
1269 case USER_ENVIRONMENT:
1270 bfin_user_init (sd, cpu, abfd, (void *)argv, (void *)env);
1272 case OPERATING_ENVIRONMENT:
1273 bfin_os_init (sd, cpu, (void *)argv);
1276 bfin_virtual_init (sd, cpu);