1 /* CRIS exception, interrupt, and trap (EIT) support
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 /* This must come before any other includes. */
23 #include "portability.h"
25 #include "sim-syscall.h"
26 #include "sim-options.h"
27 #include "sim-signal.h"
28 #include "sim/callback.h"
30 /* FIXME: get rid of targ-vals.h usage everywhere else. */
41 #ifdef HAVE_SYS_PARAM_H
42 #include <sys/param.h>
44 #ifdef HAVE_SYS_STAT_H
47 /* For PATH_MAX, originally. */
52 /* From ld/sysdep.h. */
54 # define SIM_PATHMAX PATH_MAX
57 # define SIM_PATHMAX MAXPATHLEN
59 # define SIM_PATHMAX 1024
63 /* The verbatim values are from asm-cris/unistd.h. */
65 #define TARGET_SYS_exit 1
66 #define TARGET_SYS_read 3
67 #define TARGET_SYS_write 4
68 #define TARGET_SYS_open 5
69 #define TARGET_SYS_close 6
70 #define TARGET_SYS_unlink 10
71 #define TARGET_SYS_time 13
72 #define TARGET_SYS_lseek 19
73 #define TARGET_SYS_getpid 20
74 #define TARGET_SYS_access 33
75 #define TARGET_SYS_kill 37
76 #define TARGET_SYS_rename 38
77 #define TARGET_SYS_pipe 42
78 #define TARGET_SYS_brk 45
79 #define TARGET_SYS_ioctl 54
80 #define TARGET_SYS_fcntl 55
81 #define TARGET_SYS_getppid 64
82 #define TARGET_SYS_setrlimit 75
83 #define TARGET_SYS_gettimeofday 78
84 #define TARGET_SYS_readlink 85
85 #define TARGET_SYS_munmap 91
86 #define TARGET_SYS_truncate 92
87 #define TARGET_SYS_ftruncate 93
88 #define TARGET_SYS_socketcall 102
89 #define TARGET_SYS_stat 106
90 #define TARGET_SYS_fstat 108
91 #define TARGET_SYS_wait4 114
92 #define TARGET_SYS_sigreturn 119
93 #define TARGET_SYS_clone 120
94 #define TARGET_SYS_uname 122
95 #define TARGET_SYS_mprotect 125
96 #define TARGET_SYS_llseek 140
97 #define TARGET_SYS_writev 146
98 #define TARGET_SYS__sysctl 149
99 #define TARGET_SYS_sched_setparam 154
100 #define TARGET_SYS_sched_getparam 155
101 #define TARGET_SYS_sched_setscheduler 156
102 #define TARGET_SYS_sched_getscheduler 157
103 #define TARGET_SYS_sched_yield 158
104 #define TARGET_SYS_sched_get_priority_max 159
105 #define TARGET_SYS_sched_get_priority_min 160
106 #define TARGET_SYS_mremap 163
107 #define TARGET_SYS_poll 168
108 #define TARGET_SYS_rt_sigaction 174
109 #define TARGET_SYS_rt_sigprocmask 175
110 #define TARGET_SYS_rt_sigsuspend 179
111 #define TARGET_SYS_getcwd 183
112 #define TARGET_SYS_ugetrlimit 191
113 #define TARGET_SYS_mmap2 192
114 #define TARGET_SYS_stat64 195
115 #define TARGET_SYS_lstat64 196
116 #define TARGET_SYS_fstat64 197
117 #define TARGET_SYS_geteuid32 201
118 #define TARGET_SYS_getuid32 199
119 #define TARGET_SYS_getegid32 202
120 #define TARGET_SYS_getgid32 200
121 #define TARGET_SYS_fcntl64 221
122 #define TARGET_SYS_set_thread_area 243
123 #define TARGET_SYS_exit_group 252
125 #define TARGET_PROT_READ 0x1
126 #define TARGET_PROT_WRITE 0x2
127 #define TARGET_PROT_EXEC 0x4
128 #define TARGET_PROT_NONE 0x0
130 #define TARGET_MAP_SHARED 0x01
131 #define TARGET_MAP_PRIVATE 0x02
132 #define TARGET_MAP_TYPE 0x0f
133 #define TARGET_MAP_FIXED 0x10
134 #define TARGET_MAP_ANONYMOUS 0x20
135 #define TARGET_MAP_DENYWRITE 0x800
137 #define TARGET_CTL_KERN 1
138 #define TARGET_CTL_VM 2
139 #define TARGET_CTL_NET 3
140 #define TARGET_CTL_PROC 4
141 #define TARGET_CTL_FS 5
142 #define TARGET_CTL_DEBUG 6
143 #define TARGET_CTL_DEV 7
144 #define TARGET_CTL_BUS 8
145 #define TARGET_CTL_ABI 9
147 #define TARGET_CTL_KERN_VERSION 4
150 #define TARGET_MREMAP_MAYMOVE 1
151 #define TARGET_MREMAP_FIXED 2
153 #define TARGET_TCGETS 0x5401
155 #define TARGET_UTSNAME "#7 Thu Jan 1 00:00:00 MET 2009"
157 /* Seconds since 1970-01-01 to the above date + 10 minutes;
158 'date -d "Thu Jan 1 00:00:10 MET 2009" +%s'. */
159 #define TARGET_EPOCH 1230764410
161 /* Milliseconds since start of run. We use the number of syscalls to
162 avoid introducing noise in the execution time. */
163 #define TARGET_TIME_MS(cpu) ((cpu)->syscalls)
165 /* Seconds as in time(2). */
166 #define TARGET_TIME(cpu) (TARGET_EPOCH + TARGET_TIME_MS (cpu) / 1000)
168 #define TARGET_SCHED_OTHER 0
170 #define TARGET_RLIMIT_STACK 3
171 #define TARGET_RLIMIT_NOFILE 7
173 #define SIM_TARGET_MAX_THREADS 64
174 #define SIM_MAX_ALLOC_CHUNK (512*1024*1024)
176 /* From linux/sched.h. */
177 #define TARGET_CSIGNAL 0x000000ff
178 #define TARGET_CLONE_VM 0x00000100
179 #define TARGET_CLONE_FS 0x00000200
180 #define TARGET_CLONE_FILES 0x00000400
181 #define TARGET_CLONE_SIGHAND 0x00000800
182 #define TARGET_CLONE_PID 0x00001000
183 #define TARGET_CLONE_PTRACE 0x00002000
184 #define TARGET_CLONE_VFORK 0x00004000
185 #define TARGET_CLONE_PARENT 0x00008000
186 #define TARGET_CLONE_THREAD 0x00010000
187 #define TARGET_CLONE_SIGNAL (TARGET_CLONE_SIGHAND | TARGET_CLONE_THREAD)
189 /* From asm-cris/poll.h. */
190 #define TARGET_POLLIN 1
192 /* From asm-cris/signal.h. */
193 #define TARGET_SIG_BLOCK 0
194 #define TARGET_SIG_UNBLOCK 1
195 #define TARGET_SIG_SETMASK 2
197 #define TARGET_SIG_DFL 0
198 #define TARGET_SIG_IGN 1
199 #define TARGET_SIG_ERR ((USI)-1)
201 #define TARGET_SIGHUP 1
202 #define TARGET_SIGINT 2
203 #define TARGET_SIGQUIT 3
204 #define TARGET_SIGILL 4
205 #define TARGET_SIGTRAP 5
206 #define TARGET_SIGABRT 6
207 #define TARGET_SIGIOT 6
208 #define TARGET_SIGBUS 7
209 #define TARGET_SIGFPE 8
210 #define TARGET_SIGKILL 9
211 #define TARGET_SIGUSR1 10
212 #define TARGET_SIGSEGV 11
213 #define TARGET_SIGUSR2 12
214 #define TARGET_SIGPIPE 13
215 #define TARGET_SIGALRM 14
216 #define TARGET_SIGTERM 15
217 #define TARGET_SIGSTKFLT 16
218 #define TARGET_SIGCHLD 17
219 #define TARGET_SIGCONT 18
220 #define TARGET_SIGSTOP 19
221 #define TARGET_SIGTSTP 20
222 #define TARGET_SIGTTIN 21
223 #define TARGET_SIGTTOU 22
224 #define TARGET_SIGURG 23
225 #define TARGET_SIGXCPU 24
226 #define TARGET_SIGXFSZ 25
227 #define TARGET_SIGVTALRM 26
228 #define TARGET_SIGPROF 27
229 #define TARGET_SIGWINCH 28
230 #define TARGET_SIGIO 29
231 #define TARGET_SIGPOLL SIGIO
232 /* Actually commented out in the kernel header. */
233 #define TARGET_SIGLOST 29
234 #define TARGET_SIGPWR 30
235 #define TARGET_SIGSYS 31
237 /* From include/asm-cris/signal.h. */
238 #define TARGET_SA_NOCLDSTOP 0x00000001
239 #define TARGET_SA_NOCLDWAIT 0x00000002 /* not supported yet */
240 #define TARGET_SA_SIGINFO 0x00000004
241 #define TARGET_SA_ONSTACK 0x08000000
242 #define TARGET_SA_RESTART 0x10000000
243 #define TARGET_SA_NODEFER 0x40000000
244 #define TARGET_SA_RESETHAND 0x80000000
245 #define TARGET_SA_INTERRUPT 0x20000000 /* dummy -- ignored */
246 #define TARGET_SA_RESTORER 0x04000000
248 /* From linux/wait.h. */
249 #define TARGET_WNOHANG 1
250 #define TARGET_WUNTRACED 2
251 #define TARGET___WNOTHREAD 0x20000000
252 #define TARGET___WALL 0x40000000
253 #define TARGET___WCLONE 0x80000000
255 /* From linux/limits.h. */
256 #define TARGET_PIPE_BUF 4096
259 #define TARGET_R_OK 4
260 #define TARGET_W_OK 2
261 #define TARGET_X_OK 1
262 #define TARGET_F_OK 0
264 static const char stat_map
[] =
265 "st_dev,2:space,10:space,4:st_mode,4:st_nlink,4:st_uid,4"
266 ":st_gid,4:st_rdev,2:space,10:st_size,8:st_blksize,4:st_blocks,4"
267 ":space,4:st_atime,4:space,4:st_mtime,4:space,4:st_ctime,4:space,4"
270 static const CB_TARGET_DEFS_MAP syscall_map
[] =
272 { "open", CB_SYS_open
, TARGET_SYS_open
},
273 { "close", CB_SYS_close
, TARGET_SYS_close
},
274 { "read", CB_SYS_read
, TARGET_SYS_read
},
275 { "write", CB_SYS_write
, TARGET_SYS_write
},
276 { "lseek", CB_SYS_lseek
, TARGET_SYS_lseek
},
277 { "unlink", CB_SYS_unlink
, TARGET_SYS_unlink
},
278 { "getpid", CB_SYS_getpid
, TARGET_SYS_getpid
},
279 { "fstat", CB_SYS_fstat
, TARGET_SYS_fstat64
},
280 { "lstat", CB_SYS_lstat
, TARGET_SYS_lstat64
},
281 { "stat", CB_SYS_stat
, TARGET_SYS_stat64
},
282 { "pipe", CB_SYS_pipe
, TARGET_SYS_pipe
},
283 { "rename", CB_SYS_rename
, TARGET_SYS_rename
},
284 { "truncate", CB_SYS_truncate
, TARGET_SYS_truncate
},
285 { "ftruncate", CB_SYS_ftruncate
, TARGET_SYS_ftruncate
},
289 /* An older, 32-bit-only stat mapping. */
290 static const char stat32_map
[] =
291 "st_dev,2:space,2:st_ino,4:st_mode,2:st_nlink,2:st_uid,2"
292 ":st_gid,2:st_rdev,2:space,2:st_size,4:st_blksize,4:st_blocks,4"
293 ":st_atime,4:space,4:st_mtime,4:space,4:st_ctime,4:space,12";
295 /* Map for calls using the 32-bit struct stat. Primarily used by the
296 newlib Linux mapping. */
297 static const CB_TARGET_DEFS_MAP syscall_stat32_map
[] =
299 { "fstat", CB_SYS_fstat
, TARGET_SYS_fstat
},
300 { "stat", CB_SYS_stat
, TARGET_SYS_stat
},
304 /* Giving the true value for the running sim process will lead to
305 non-time-invariant behavior. */
306 #define TARGET_PID 42
308 /* Unfortunately, we don't get this from cris.cpu at the moment, and if
309 we did, we'd still don't get a register number with the "16" offset. */
310 #define TARGET_SRP_REGNUM (16+11)
312 /* Extracted by applying
313 awk '/^#define/ { printf "#ifdef %s\n { %s, %s },\n#endif\n", $2, $2, $3;}'
314 on .../include/asm/errno.h in a GNU/Linux/CRIS installation and
315 adjusting the synonyms. */
317 static const CB_TARGET_DEFS_MAP errno_map
[] =
320 { "EPERM", EPERM
, 1 },
323 { "ENOENT", ENOENT
, 2 },
326 { "ESRCH", ESRCH
, 3 },
329 { "EINTR", EINTR
, 4 },
335 { "ENXIO", ENXIO
, 6 },
338 { "E2BIG", E2BIG
, 7 },
341 { "ENOEXEC", ENOEXEC
, 8 },
344 { "EBADF", EBADF
, 9 },
347 { "ECHILD", ECHILD
, 10 },
350 { "EAGAIN", EAGAIN
, 11 },
353 { "ENOMEM", ENOMEM
, 12 },
356 { "EACCES", EACCES
, 13 },
359 { "EFAULT", EFAULT
, 14 },
362 { "ENOTBLK", ENOTBLK
, 15 },
365 { "EBUSY", EBUSY
, 16 },
368 { "EEXIST", EEXIST
, 17 },
371 { "EXDEV", EXDEV
, 18 },
374 { "ENODEV", ENODEV
, 19 },
377 { "ENOTDIR", ENOTDIR
, 20 },
380 { "EISDIR", EISDIR
, 21 },
383 { "EINVAL", EINVAL
, 22 },
386 { "ENFILE", ENFILE
, 23 },
389 { "EMFILE", EMFILE
, 24 },
392 { "ENOTTY", ENOTTY
, 25 },
395 { "ETXTBSY", ETXTBSY
, 26 },
398 { "EFBIG", EFBIG
, 27 },
401 { "ENOSPC", ENOSPC
, 28 },
404 { "ESPIPE", ESPIPE
, 29 },
407 { "EROFS", EROFS
, 30 },
410 { "EMLINK", EMLINK
, 31 },
413 { "EPIPE", EPIPE
, 32 },
416 { "EDOM", EDOM
, 33 },
419 { "ERANGE", ERANGE
, 34 },
422 { "EDEADLK", EDEADLK
, 35 },
425 { "ENAMETOOLONG", ENAMETOOLONG
, 36 },
428 { "ENOLCK", ENOLCK
, 37 },
431 { "ENOSYS", ENOSYS
, 38 },
434 { "ENOTEMPTY", ENOTEMPTY
, 39 },
437 { "ELOOP", ELOOP
, 40 },
440 { "EWOULDBLOCK", EWOULDBLOCK
, 11 },
443 { "ENOMSG", ENOMSG
, 42 },
446 { "EIDRM", EIDRM
, 43 },
449 { "ECHRNG", ECHRNG
, 44 },
452 { "EL2NSYNC", EL2NSYNC
, 45 },
455 { "EL3HLT", EL3HLT
, 46 },
458 { "EL3RST", EL3RST
, 47 },
461 { "ELNRNG", ELNRNG
, 48 },
464 { "EUNATCH", EUNATCH
, 49 },
467 { "ENOCSI", ENOCSI
, 50 },
470 { "EL2HLT", EL2HLT
, 51 },
473 { "EBADE", EBADE
, 52 },
476 { "EBADR", EBADR
, 53 },
479 { "EXFULL", EXFULL
, 54 },
482 { "ENOANO", ENOANO
, 55 },
485 { "EBADRQC", EBADRQC
, 56 },
488 { "EBADSLT", EBADSLT
, 57 },
491 { "EDEADLOCK", EDEADLOCK
, 35 },
494 { "EBFONT", EBFONT
, 59 },
497 { "ENOSTR", ENOSTR
, 60 },
500 { "ENODATA", ENODATA
, 61 },
503 { "ETIME", ETIME
, 62 },
506 { "ENOSR", ENOSR
, 63 },
509 { "ENONET", ENONET
, 64 },
512 { "ENOPKG", ENOPKG
, 65 },
515 { "EREMOTE", EREMOTE
, 66 },
518 { "ENOLINK", ENOLINK
, 67 },
521 { "EADV", EADV
, 68 },
524 { "ESRMNT", ESRMNT
, 69 },
527 { "ECOMM", ECOMM
, 70 },
530 { "EPROTO", EPROTO
, 71 },
533 { "EMULTIHOP", EMULTIHOP
, 72 },
536 { "EDOTDOT", EDOTDOT
, 73 },
539 { "EBADMSG", EBADMSG
, 74 },
542 { "EOVERFLOW", EOVERFLOW
, 75 },
545 { "ENOTUNIQ", ENOTUNIQ
, 76 },
548 { "EBADFD", EBADFD
, 77 },
551 { "EREMCHG", EREMCHG
, 78 },
554 { "ELIBACC", ELIBACC
, 79 },
557 { "ELIBBAD", ELIBBAD
, 80 },
560 { "ELIBSCN", ELIBSCN
, 81 },
563 { "ELIBMAX", ELIBMAX
, 82 },
566 { "ELIBEXEC", ELIBEXEC
, 83 },
569 { "EILSEQ", EILSEQ
, 84 },
572 { "ERESTART", ERESTART
, 85 },
575 { "ESTRPIPE", ESTRPIPE
, 86 },
578 { "EUSERS", EUSERS
, 87 },
581 { "ENOTSOCK", ENOTSOCK
, 88 },
584 { "EDESTADDRREQ", EDESTADDRREQ
, 89 },
587 { "EMSGSIZE", EMSGSIZE
, 90 },
590 { "EPROTOTYPE", EPROTOTYPE
, 91 },
593 { "ENOPROTOOPT", ENOPROTOOPT
, 92 },
595 #ifdef EPROTONOSUPPORT
596 { "EPROTONOSUPPORT", EPROTONOSUPPORT
, 93 },
598 #ifdef ESOCKTNOSUPPORT
599 { "ESOCKTNOSUPPORT", ESOCKTNOSUPPORT
, 94 },
602 { "EOPNOTSUPP", EOPNOTSUPP
, 95 },
605 { "EPFNOSUPPORT", EPFNOSUPPORT
, 96 },
608 { "EAFNOSUPPORT", EAFNOSUPPORT
, 97 },
611 { "EADDRINUSE", EADDRINUSE
, 98 },
614 { "EADDRNOTAVAIL", EADDRNOTAVAIL
, 99 },
617 { "ENETDOWN", ENETDOWN
, 100 },
620 { "ENETUNREACH", ENETUNREACH
, 101 },
623 { "ENETRESET", ENETRESET
, 102 },
626 { "ECONNABORTED", ECONNABORTED
, 103 },
629 { "ECONNRESET", ECONNRESET
, 104 },
632 { "ENOBUFS", ENOBUFS
, 105 },
635 { "EISCONN", EISCONN
, 106 },
638 { "ENOTCONN", ENOTCONN
, 107 },
641 { "ESHUTDOWN", ESHUTDOWN
, 108 },
644 { "ETOOMANYREFS", ETOOMANYREFS
, 109 },
647 { "ETIMEDOUT", ETIMEDOUT
, 110 },
650 { "ECONNREFUSED", ECONNREFUSED
, 111 },
653 { "EHOSTDOWN", EHOSTDOWN
, 112 },
656 { "EHOSTUNREACH", EHOSTUNREACH
, 113 },
659 { "EALREADY", EALREADY
, 114 },
662 { "EINPROGRESS", EINPROGRESS
, 115 },
665 { "ESTALE", ESTALE
, 116 },
668 { "EUCLEAN", EUCLEAN
, 117 },
671 { "ENOTNAM", ENOTNAM
, 118 },
674 { "ENAVAIL", ENAVAIL
, 119 },
677 { "EISNAM", EISNAM
, 120 },
680 { "EREMOTEIO", EREMOTEIO
, 121 },
683 { "EDQUOT", EDQUOT
, 122 },
686 { "ENOMEDIUM", ENOMEDIUM
, 123 },
689 { "EMEDIUMTYPE", EMEDIUMTYPE
, 124 },
694 /* Extracted by applying
695 perl -ne 'if ($_ =~ /^#define/) { split;
696 printf "#ifdef $_[1]\n { %s, 0x%x },\n#endif\n",
697 $_[1], $_[2] =~ /^0/ ? oct($_[2]) : $_[2];}'
698 on pertinent parts of .../include/asm/fcntl.h in a GNU/Linux/CRIS
699 installation and removing synonyms and unnecessary items. Don't
700 forget the end-marker. */
702 /* These we treat specially, as they're used in the fcntl F_GETFL
703 syscall. For consistency, open_map is also manually edited to use
705 #define TARGET_O_ACCMODE 0x3
706 #define TARGET_O_RDONLY 0x0
707 #define TARGET_O_WRONLY 0x1
709 static const CB_TARGET_DEFS_MAP open_map
[] = {
711 { "O_ACCMODE", O_ACCMODE
, TARGET_O_ACCMODE
},
714 { "O_RDONLY", O_RDONLY
, TARGET_O_RDONLY
},
717 { "O_WRONLY", O_WRONLY
, TARGET_O_WRONLY
},
720 { "O_RDWR", O_RDWR
, 0x2 },
723 { "O_CREAT", O_CREAT
, 0x40 },
726 { "O_EXCL", O_EXCL
, 0x80 },
729 { "O_NOCTTY", O_NOCTTY
, 0x100 },
732 { "O_TRUNC", O_TRUNC
, 0x200 },
735 { "O_APPEND", O_APPEND
, 0x400 },
738 { "O_NONBLOCK", O_NONBLOCK
, 0x800 },
741 { "O_NDELAY", O_NDELAY
, 0x0 },
744 { "O_SYNC", O_SYNC
, 0x1000 },
747 { "FASYNC", FASYNC
, 0x2000 },
750 { "O_DIRECT", O_DIRECT
, 0x4000 },
753 { "O_LARGEFILE", O_LARGEFILE
, 0x8000 },
756 { "O_DIRECTORY", O_DIRECTORY
, 0x10000 },
759 { "O_NOFOLLOW", O_NOFOLLOW
, 0x20000 },
764 /* Let's be less drastic and more traceable. FIXME: mark as noreturn. */
766 sim_io_error (sd, "simulator unhandled condition at %s:%d", \
767 __FUNCTION__, __LINE__)
769 /* Needed for the cris_pipe_nonempty and cris_pipe_empty syscalls. */
770 static SIM_CPU
*current_cpu_for_cb_callback
;
772 static USI
create_map (SIM_DESC
, struct cris_sim_mmapped_page
**,
774 static USI
unmap_pages (SIM_DESC
, struct cris_sim_mmapped_page
**,
776 static USI
is_mapped (SIM_DESC
, struct cris_sim_mmapped_page
**,
778 static void dump_statistics (SIM_CPU
*current_cpu
);
779 static void make_first_thread (SIM_CPU
*current_cpu
);
781 /* When we risk running self-modified code (as in trampolines), this is
782 called from special-case insns. The silicon CRIS CPU:s have enough
783 cache snooping implemented making this a simulator-only issue. Tests:
784 gcc.c-torture/execute/931002-1.c execution, -O3 -g
785 gcc.c-torture/execute/931002-1.c execution, -O3 -fomit-frame-pointer. */
788 cris_flush_simulator_decode_cache (SIM_CPU
*current_cpu
,
789 USI pc ATTRIBUTE_UNUSED
)
791 SIM_DESC sd
= CPU_STATE (current_cpu
);
794 if (USING_SCACHE_P (sd
))
795 scache_flush_cpu (current_cpu
);
799 /* Output statistics at the end of a run. */
801 dump_statistics (SIM_CPU
*current_cpu
)
803 SIM_DESC sd
= CPU_STATE (current_cpu
);
804 CRIS_MISC_PROFILE
*profp
805 = CPU_CRIS_MISC_PROFILE (current_cpu
);
806 unsigned64 total
= profp
->basic_cycle_count
;
808 /* Historically, these messages have gone to stderr, so we'll keep it
809 that way. It's also easier to then tell it from normal program
810 output. FIXME: Add redirect option like "run -e file". */
812 /* The --cris-stats={basic|unaligned|schedulable|all} counts affect
813 what's included in the "total" count only. */
814 switch (CPU_CRIS_MISC_PROFILE (current_cpu
)->flags
815 & FLAG_CRIS_MISC_PROFILE_ALL
)
817 case FLAG_CRIS_MISC_PROFILE_SIMPLE
:
818 sim_io_eprintf (sd
, "Basic clock cycles, total @: %" PRIu64
"\n", total
);
821 case (FLAG_CRIS_MISC_PROFILE_UNALIGNED
| FLAG_CRIS_MISC_PROFILE_SIMPLE
):
822 total
+= profp
->unaligned_mem_dword_count
;
824 "Clock cycles including stall cycles for unaligned "
825 "accesses @: %" PRIu64
"\n",
829 case (FLAG_CRIS_MISC_PROFILE_SCHEDULABLE
| FLAG_CRIS_MISC_PROFILE_SIMPLE
):
831 += (profp
->memsrc_stall_count
832 + profp
->memraw_stall_count
833 + profp
->movemsrc_stall_count
834 + profp
->movemdst_stall_count
835 + profp
->mulsrc_stall_count
836 + profp
->jumpsrc_stall_count
837 + profp
->unaligned_mem_dword_count
);
838 sim_io_eprintf (sd
, "Schedulable clock cycles, total @: %" PRIu64
"\n",
842 case FLAG_CRIS_MISC_PROFILE_ALL
:
844 += (profp
->memsrc_stall_count
845 + profp
->memraw_stall_count
846 + profp
->movemsrc_stall_count
847 + profp
->movemdst_stall_count
848 + profp
->movemaddr_stall_count
849 + profp
->mulsrc_stall_count
850 + profp
->jumpsrc_stall_count
851 + profp
->branch_stall_count
852 + profp
->jumptarget_stall_count
853 + profp
->unaligned_mem_dword_count
);
854 sim_io_eprintf (sd
, "All accounted clock cycles, total @: %" PRIu64
"\n",
859 sim_engine_abort (sd
, current_cpu
, 0,
860 "Internal inconsistency at %s:%d",
864 /* For v32, unaligned_mem_dword_count should always be 0. For
865 v10, memsrc_stall_count should always be 0. */
866 sim_io_eprintf (sd
, "Memory source stall cycles: %" PRIu64
"\n",
867 profp
->memsrc_stall_count
+ profp
->unaligned_mem_dword_count
);
868 sim_io_eprintf (sd
, "Memory read-after-write stall cycles: %" PRIu64
"\n",
869 profp
->memraw_stall_count
);
870 sim_io_eprintf (sd
, "Movem source stall cycles: %" PRIu64
"\n",
871 profp
->movemsrc_stall_count
);
872 sim_io_eprintf (sd
, "Movem destination stall cycles: %" PRIu64
"\n",
873 profp
->movemdst_stall_count
);
874 sim_io_eprintf (sd
, "Movem address stall cycles: %" PRIu64
"\n",
875 profp
->movemaddr_stall_count
);
876 sim_io_eprintf (sd
, "Multiplication source stall cycles: %" PRIu64
"\n",
877 profp
->mulsrc_stall_count
);
878 sim_io_eprintf (sd
, "Jump source stall cycles: %" PRIu64
"\n",
879 profp
->jumpsrc_stall_count
);
880 sim_io_eprintf (sd
, "Branch misprediction stall cycles: %" PRIu64
"\n",
881 profp
->branch_stall_count
);
882 sim_io_eprintf (sd
, "Jump target stall cycles: %" PRIu64
"\n",
883 profp
->jumptarget_stall_count
);
886 /* Check whether any part of [addr .. addr + len - 1] is already mapped.
887 Return 1 if a overlap detected, 0 otherwise. */
890 is_mapped (SIM_DESC sd ATTRIBUTE_UNUSED
,
891 struct cris_sim_mmapped_page
**rootp
,
894 struct cris_sim_mmapped_page
*mapp
;
896 if (len
== 0 || (len
& 8191))
899 /* Iterate over the reverse-address sorted pages until we find a page in
900 or lower than the checked area. */
901 for (mapp
= *rootp
; mapp
!= NULL
&& mapp
->addr
>= addr
; mapp
= mapp
->prev
)
902 if (mapp
->addr
< addr
+ len
&& mapp
->addr
>= addr
)
908 /* Check whether any part of [addr .. addr + len - 1] is *un*mapped.
909 Return 1 if the whole area is mapped, 0 otherwise. */
912 is_mapped_only (SIM_DESC sd ATTRIBUTE_UNUSED
,
913 struct cris_sim_mmapped_page
**rootp
,
916 struct cris_sim_mmapped_page
*mapp
;
918 if (len
== 0 || (len
& 8191))
921 /* Iterate over the reverse-address sorted pages until we find a page
922 lower than the checked area. */
923 for (mapp
= *rootp
; mapp
!= NULL
&& mapp
->addr
>= addr
; mapp
= mapp
->prev
)
924 if (addr
== mapp
->addr
&& len
== 8192)
926 else if (addr
+ len
> mapp
->addr
)
932 /* Debug helper; to be run from gdb. */
935 cris_dump_map (SIM_CPU
*current_cpu
)
937 struct cris_sim_mmapped_page
*mapp
;
940 for (mapp
= current_cpu
->highest_mmapped_page
,
941 start
= mapp
== NULL
? 0 : mapp
->addr
+ 8192,
942 end
= mapp
== NULL
? 0 : mapp
->addr
+ 8191;
946 if (mapp
->addr
!= start
- 8192)
948 sim_io_eprintf (CPU_STATE (current_cpu
), "0x%x..0x%x\n", start
, end
);
949 end
= mapp
->addr
+ 8191;
955 if (current_cpu
->highest_mmapped_page
!= NULL
)
956 sim_io_eprintf (CPU_STATE (current_cpu
), "0x%x..0x%x\n", start
, end
);
959 /* Create mmapped memory. ADDR is -1 if any address will do. Caller
960 must make sure that the address isn't already mapped. */
963 create_map (SIM_DESC sd
, struct cris_sim_mmapped_page
**rootp
, USI addr
,
966 struct cris_sim_mmapped_page
*mapp
;
967 struct cris_sim_mmapped_page
**higher_prevp
= rootp
;
968 USI new_addr
= 0x40000000;
970 if (addr
!= (USI
) -1)
972 else if (*rootp
&& rootp
[0]->addr
>= new_addr
)
973 new_addr
= rootp
[0]->addr
+ 8192;
980 /* Which is better: return an error for this, or just round it up? */
983 /* Do a recursive call for each page in the request. */
984 for (page_addr
= new_addr
; len
!= 0; page_addr
+= 8192, len
-= 8192)
985 if (create_map (sd
, rootp
, page_addr
, 8192) >= (USI
) -8191)
992 mapp
!= NULL
&& mapp
->addr
> new_addr
;
994 higher_prevp
= &mapp
->prev
;
996 /* Assert for consistency that we don't create duplicate maps. */
997 if (is_mapped (sd
, rootp
, new_addr
, len
))
1000 /* Allocate the new page, on the next higher page from the last one
1001 allocated, and link in the new descriptor before previous ones. */
1002 mapp
= malloc (sizeof (*mapp
));
1005 return (USI
) -ENOMEM
;
1007 sim_core_attach (sd
, NULL
, 0, access_read_write_exec
, 0,
1011 mapp
->addr
= new_addr
;
1012 mapp
->prev
= *higher_prevp
;
1013 *higher_prevp
= mapp
;
1018 /* Unmap one or more pages. */
1021 unmap_pages (SIM_DESC sd
, struct cris_sim_mmapped_page
**rootp
, USI addr
,
1024 struct cris_sim_mmapped_page
*mapp
;
1025 struct cris_sim_mmapped_page
**higher_prevp
= rootp
;
1033 /* Which is better: return an error for this, or just round it up? */
1036 /* Loop backwards to make each call is O(1) over the number of pages
1037 allocated, if we're unmapping from the high end of the pages. */
1038 for (page_addr
= addr
+ len
- 8192;
1041 if (unmap_pages (sd
, rootp
, page_addr
, 8192))
1044 if (unmap_pages (sd
, rootp
, addr
, 8192))
1050 for (mapp
= *rootp
; mapp
!= NULL
&& mapp
->addr
> addr
; mapp
= mapp
->prev
)
1051 higher_prevp
= &mapp
->prev
;
1053 if (mapp
== NULL
|| mapp
->addr
!= addr
)
1056 *higher_prevp
= mapp
->prev
;
1057 sim_core_detach (sd
, NULL
, 0, 0, addr
);
1062 /* The semantic code invokes this for illegal (unrecognized) instructions. */
1065 sim_engine_invalid_insn (SIM_CPU
*current_cpu
, IADDR cia
, SEM_PC vpc
)
1067 SIM_DESC sd
= CPU_STATE (current_cpu
);
1069 sim_engine_halt (sd
, current_cpu
, NULL
, cia
, sim_stopped
, SIM_SIGILL
);
1073 /* Handlers from the CGEN description that should not be called. */
1076 cris_bmod_handler (SIM_CPU
*current_cpu ATTRIBUTE_UNUSED
,
1077 UINT srcreg ATTRIBUTE_UNUSED
,
1078 USI dstreg ATTRIBUTE_UNUSED
)
1080 SIM_DESC sd
= CPU_STATE (current_cpu
);
1085 h_supr_set_handler (SIM_CPU
*current_cpu ATTRIBUTE_UNUSED
,
1086 UINT index ATTRIBUTE_UNUSED
,
1087 USI page ATTRIBUTE_UNUSED
,
1088 USI newval ATTRIBUTE_UNUSED
)
1090 SIM_DESC sd
= CPU_STATE (current_cpu
);
1095 h_supr_get_handler (SIM_CPU
*current_cpu ATTRIBUTE_UNUSED
,
1096 UINT index ATTRIBUTE_UNUSED
,
1097 USI page ATTRIBUTE_UNUSED
)
1099 SIM_DESC sd
= CPU_STATE (current_cpu
);
1103 /* Swap one context for another. */
1106 schedule (SIM_CPU
*current_cpu
, int next
)
1108 /* Need to mark context-switches in the trace output. */
1109 if ((CPU_CRIS_MISC_PROFILE (current_cpu
)->flags
1110 & FLAG_CRIS_MISC_PROFILE_XSIM_TRACE
))
1111 cris_trace_printf (CPU_STATE (current_cpu
), current_cpu
,
1114 /* Copy the current context (if there is one) to its slot. */
1115 if (current_cpu
->thread_data
[current_cpu
->threadno
].cpu_context
)
1116 memcpy (current_cpu
->thread_data
[current_cpu
->threadno
].cpu_context
,
1117 ¤t_cpu
->cpu_data_placeholder
,
1118 current_cpu
->thread_cpu_data_size
);
1120 /* Copy the new context from its slot. */
1121 memcpy (¤t_cpu
->cpu_data_placeholder
,
1122 current_cpu
->thread_data
[next
].cpu_context
,
1123 current_cpu
->thread_cpu_data_size
);
1125 /* Update needed stuff to indicate the new context. */
1126 current_cpu
->threadno
= next
;
1128 /* Handle pending signals. */
1129 if (current_cpu
->thread_data
[next
].sigpending
1130 /* We don't run nested signal handlers. This means that pause(2)
1131 and sigsuspend(2) do not work in sighandlers, but that
1132 shouldn't be too hard a restriction. It also greatly
1133 simplifies the code. */
1134 && current_cpu
->thread_data
[next
].cpu_context_atsignal
== NULL
)
1138 /* See if there's really a pending, non-blocked handler. We don't
1139 queue signals, so just use the first one in ascending order. */
1140 for (sig
= 0; sig
< 64; sig
++)
1141 if (current_cpu
->thread_data
[next
].sigdata
[sig
].pending
1142 && !current_cpu
->thread_data
[next
].sigdata
[sig
].blocked
)
1148 USI pc
= sim_pc_get (current_cpu
);
1150 /* It's simpler to save the CPU context inside the simulator
1151 than on the stack. */
1152 current_cpu
->thread_data
[next
].cpu_context_atsignal
1154 ->make_thread_cpu_data
) (current_cpu
,
1155 current_cpu
->thread_data
[next
]
1158 (*CPU_REG_FETCH (current_cpu
)) (current_cpu
, H_GR_SP
, regbuf
, 4);
1159 sp
= bfd_getl32 (regbuf
);
1161 /* Make sure we have an aligned stack. */
1164 /* Make room for the signal frame, aligned. FIXME: Check that
1165 the memory exists, map it in if absent. (BTW, should also
1166 implement on-access automatic stack allocation). */
1169 /* This isn't the same signal frame as the kernel uses, because
1170 we don't want to bother getting all registers on and off the
1173 /* First, we store the currently blocked signals. */
1175 for (i
= 0; i
< 32; i
++)
1177 |= current_cpu
->thread_data
[next
].sigdata
[i
+ 1].blocked
<< i
;
1178 sim_core_write_aligned_4 (current_cpu
, pc
, 0, sp
, blocked
);
1180 for (i
= 0; i
< 31; i
++)
1182 |= current_cpu
->thread_data
[next
].sigdata
[i
+ 33].blocked
<< i
;
1183 sim_core_write_aligned_4 (current_cpu
, pc
, 0, sp
+ 4, blocked
);
1185 /* Then, the actual instructions. This is CPU-specific, but we
1186 use instructions from the common subset for v10 and v32 which
1187 should be safe for the time being but could be parametrized
1189 /* MOVU.W [PC+],R9. */
1190 sim_core_write_aligned_2 (current_cpu
, pc
, 0, sp
+ 8, 0x9c5f);
1191 /* .WORD TARGET_SYS_sigreturn. */
1192 sim_core_write_aligned_2 (current_cpu
, pc
, 0, sp
+ 10,
1193 TARGET_SYS_sigreturn
);
1195 sim_core_write_aligned_2 (current_cpu
, pc
, 0, sp
+ 12, 0xe93d);
1197 /* NOP (on v32; it's SETF on v10, but is the correct compatible
1198 instruction. Still, it doesn't matter because v10 has no
1199 delay slot for BREAK so it will not be executed). */
1200 sim_core_write_aligned_2 (current_cpu
, pc
, 0, sp
+ 16, 0x05b0);
1202 /* Modify registers to hold the right values for the sighandler
1203 context: updated stackpointer and return address pointing to
1204 the sigreturn stub. */
1205 bfd_putl32 (sp
, regbuf
);
1206 (*CPU_REG_STORE (current_cpu
)) (current_cpu
, H_GR_SP
, regbuf
, 4);
1207 bfd_putl32 (sp
+ 8, regbuf
);
1208 (*CPU_REG_STORE (current_cpu
)) (current_cpu
, TARGET_SRP_REGNUM
,
1211 current_cpu
->thread_data
[next
].sigdata
[sig
].pending
= 0;
1213 /* Block this signal (for the duration of the sighandler). */
1214 current_cpu
->thread_data
[next
].sigdata
[sig
].blocked
= 1;
1216 sim_pc_set (current_cpu
, current_cpu
->sighandler
[sig
]);
1217 bfd_putl32 (sig
, regbuf
);
1218 (*CPU_REG_STORE (current_cpu
)) (current_cpu
, H_GR_R10
,
1221 /* We ignore a SA_SIGINFO flag in the sigaction call; the code I
1222 needed all this for, specifies a SA_SIGINFO call but treats it
1223 like an ordinary sighandler; only the signal number argument is
1224 inspected. To make future need to implement SA_SIGINFO
1225 correctly possible, we set the siginfo argument register to a
1226 magic (hopefully non-address) number. (NB: then, you should
1227 just need to pass the siginfo argument; it seems you probably
1228 don't need to implement the specific rt_sigreturn.) */
1229 bfd_putl32 (0xbad5161f, regbuf
);
1230 (*CPU_REG_STORE (current_cpu
)) (current_cpu
, H_GR_R11
,
1233 /* The third argument is unused and the kernel sets it to 0. */
1234 bfd_putl32 (0, regbuf
);
1235 (*CPU_REG_STORE (current_cpu
)) (current_cpu
, H_GR_R12
,
1240 /* No, there actually was no pending signal for this thread. Reset
1242 current_cpu
->thread_data
[next
].sigpending
= 0;
1246 /* Reschedule the simplest possible way until something else is absolutely
1248 - A. Find the next process (round-robin) that doesn't have at_syscall
1250 - B. If there is none, just run the next process, round-robin.
1251 - Clear at_syscall for the current process. */
1254 reschedule (SIM_CPU
*current_cpu
)
1256 SIM_DESC sd
= CPU_STATE (current_cpu
);
1259 /* Iterate over all thread slots, because after a few thread creations
1260 and exits, we don't know where the live ones are. */
1261 for (i
= (current_cpu
->threadno
+ 1) % SIM_TARGET_MAX_THREADS
;
1262 i
!= current_cpu
->threadno
;
1263 i
= (i
+ 1) % SIM_TARGET_MAX_THREADS
)
1264 if (current_cpu
->thread_data
[i
].cpu_context
1265 && current_cpu
->thread_data
[i
].at_syscall
== 0)
1267 schedule (current_cpu
, i
);
1271 /* Pick any next live thread. */
1272 for (i
= (current_cpu
->threadno
+ 1) % SIM_TARGET_MAX_THREADS
;
1273 i
!= current_cpu
->threadno
;
1274 i
= (i
+ 1) % SIM_TARGET_MAX_THREADS
)
1275 if (current_cpu
->thread_data
[i
].cpu_context
)
1277 schedule (current_cpu
, i
);
1281 /* More than one live thread, but we couldn't find the next one? */
1285 /* Set up everything to receive (or IGN) an incoming signal to the
1289 deliver_signal (SIM_CPU
*current_cpu
, int sig
, unsigned int pid
)
1292 USI pc
= sim_pc_get (current_cpu
);
1294 /* Find the thread index of the pid. */
1295 for (i
= 0; i
< SIM_TARGET_MAX_THREADS
; i
++)
1296 /* Apparently it's ok to send signals to zombies (so a check for
1297 current_cpu->thread_data[i].cpu_context != NULL would be
1299 if (current_cpu
->thread_data
[i
].threadid
== pid
- TARGET_PID
)
1302 switch (current_cpu
->sighandler
[sig
])
1304 case TARGET_SIG_DFL
:
1307 /* The following according to the glibc
1308 documentation. (The kernel code has non-obvious
1309 execution paths.) */
1312 case TARGET_SIGSEGV
:
1314 case TARGET_SIGABRT
:
1315 case TARGET_SIGTRAP
:
1318 case TARGET_SIGTERM
:
1320 case TARGET_SIGQUIT
:
1321 case TARGET_SIGKILL
:
1324 case TARGET_SIGALRM
:
1325 case TARGET_SIGVTALRM
:
1326 case TARGET_SIGPROF
:
1327 case TARGET_SIGSTOP
:
1329 case TARGET_SIGPIPE
:
1330 case TARGET_SIGLOST
:
1331 case TARGET_SIGXCPU
:
1332 case TARGET_SIGXFSZ
:
1333 case TARGET_SIGUSR1
:
1334 case TARGET_SIGUSR2
:
1335 sim_io_eprintf (CPU_STATE (current_cpu
),
1336 "Exiting pid %d due to signal %d\n",
1338 sim_engine_halt (CPU_STATE (current_cpu
), current_cpu
,
1339 NULL
, pc
, sim_stopped
,
1340 sig
== TARGET_SIGABRT
1341 ? SIM_SIGABRT
: SIM_SIGILL
);
1344 /* The default for all other signals is to be ignored. */
1349 case TARGET_SIG_IGN
:
1352 case TARGET_SIGKILL
:
1353 case TARGET_SIGSTOP
:
1354 /* Can't ignore these signals. */
1355 sim_io_eprintf (CPU_STATE (current_cpu
),
1356 "Exiting pid %d due to signal %d\n",
1358 sim_engine_halt (CPU_STATE (current_cpu
), current_cpu
,
1359 NULL
, pc
, sim_stopped
, SIM_SIGILL
);
1368 /* Mark the signal as pending, making schedule () check
1369 closer. The signal will be handled when the thread is
1370 scheduled and the signal is unblocked. */
1371 current_cpu
->thread_data
[i
].sigdata
[sig
].pending
= 1;
1372 current_cpu
->thread_data
[i
].sigpending
= 1;
1377 sim_io_eprintf (CPU_STATE (current_cpu
),
1378 "Unimplemented signal: %d\n", sig
);
1379 sim_engine_halt (CPU_STATE (current_cpu
), current_cpu
, NULL
, pc
,
1380 sim_stopped
, SIM_SIGILL
);
1385 -cb_host_to_target_errno (STATE_CALLBACK (CPU_STATE (current_cpu
)),
1389 /* Make the vector and the first item, the main thread. */
1392 make_first_thread (SIM_CPU
*current_cpu
)
1394 SIM_DESC sd
= CPU_STATE (current_cpu
);
1395 current_cpu
->thread_data
1397 SIM_TARGET_MAX_THREADS
1398 * sizeof (current_cpu
->thread_data
[0]));
1399 current_cpu
->thread_data
[0].cpu_context
1400 = (*current_cpu
->make_thread_cpu_data
) (current_cpu
,
1402 ->cpu_data_placeholder
);
1403 current_cpu
->thread_data
[0].parent_threadid
= -1;
1405 /* For good measure. */
1406 if (TARGET_SIG_DFL
!= 0)
1410 /* Handle unknown system calls. Returns (if it does) the syscall
1414 cris_unknown_syscall (SIM_CPU
*current_cpu
, USI pc
, char *s
, ...)
1416 SIM_DESC sd
= CPU_STATE (current_cpu
);
1417 host_callback
*cb
= STATE_CALLBACK (sd
);
1419 if (cris_unknown_syscall_action
== CRIS_USYSC_MSG_STOP
1420 || cris_unknown_syscall_action
== CRIS_USYSC_MSG_ENOSYS
)
1425 sim_io_evprintf (sd
, s
, ap
);
1428 if (cris_unknown_syscall_action
== CRIS_USYSC_MSG_STOP
)
1429 sim_engine_halt (sd
, current_cpu
, NULL
, pc
, sim_stopped
, SIM_SIGILL
);
1432 return -cb_host_to_target_errno (cb
, ENOSYS
);
1435 /* Main function: the handler of the "break 13" syscall insn. */
1438 cris_break_13_handler (SIM_CPU
*current_cpu
, USI callnum
, USI arg1
,
1439 USI arg2
, USI arg3
, USI arg4
, USI arg5
, USI arg6
,
1443 SIM_DESC sd
= CPU_STATE (current_cpu
);
1444 host_callback
*cb
= STATE_CALLBACK (sd
);
1446 int threadno
= current_cpu
->threadno
;
1448 current_cpu
->syscalls
++;
1450 CB_SYSCALL_INIT (&s
);
1456 /* The type of s.arg2 is long, so for hosts with 64-bit longs, we need
1457 to sign-extend the lseek offset to be passed as a signed number,
1458 else we'll truncate it to something > 2GB on hosts where sizeof
1459 long > sizeof USI. We avoid doing it for all syscalls, as arg2 is
1460 e.g. an address for some syscalls. */
1461 if (callnum
== TARGET_SYS_lseek
)
1464 if (callnum
== TARGET_SYS_exit_group
1465 || (callnum
== TARGET_SYS_exit
&& current_cpu
->m1threads
== 0))
1467 if (CPU_CRIS_MISC_PROFILE (current_cpu
)->flags
1468 & FLAG_CRIS_MISC_PROFILE_ALL
)
1469 dump_statistics (current_cpu
);
1470 sim_engine_halt (sd
, current_cpu
, NULL
, pc
, sim_exited
, arg1
);
1474 s
.p2
= (PTR
) current_cpu
;
1475 s
.read_mem
= sim_syscall_read_mem
;
1476 s
.write_mem
= sim_syscall_write_mem
;
1478 current_cpu_for_cb_callback
= current_cpu
;
1480 if (cb_syscall (cb
, &s
) != CB_RC_OK
)
1482 sim_engine_abort (sd
, current_cpu
, pc
,
1483 "Break 13: invalid %d? Returned %ld\n", callnum
,
1487 retval
= s
.result
== -1 ? -s
.errcode
: s
.result
;
1489 if (s
.errcode
!= 0 && s
.errcode
== cb_host_to_target_errno (cb
, ENOSYS
))
1491 /* If the generic simulator call said ENOSYS, then let's try the
1492 ones we know ourselves.
1494 The convention is to provide *very limited* functionality on an
1495 as-needed basis, only what's covered by the test-suite, tests
1496 added when functionality changes and abort with a descriptive
1497 message for *everything* else. Where there's no test-case, we
1502 /* It's a pretty safe bet that the "old setup() system call"
1503 number will not be re-used; we can't say the same for higher
1504 numbers. We treat this simulator-generated call as "wait
1505 forever"; we re-run this insn. The wait is ended by a
1506 callback. Sanity check that this is the reason we got
1508 if (current_cpu
->thread_data
== NULL
1509 || (current_cpu
->thread_data
[threadno
].pipe_write_fd
== 0))
1510 goto unimplemented_syscall
;
1512 sim_pc_set (current_cpu
, pc
);
1516 case TARGET_SYS_fcntl64
:
1517 case TARGET_SYS_fcntl
:
1522 Glibc checks stdin, stdout and stderr fd:s for
1523 close-on-exec security sanity. We just need to provide a
1524 OK return value. If we really need to have a
1525 close-on-exec flag true, we could just do a real fcntl
1531 /* F_SETFD. Just ignore attempts to set the close-on-exec
1537 /* F_GETFL. Check for the special case for open+fdopen. */
1538 if (current_cpu
->last_syscall
== TARGET_SYS_open
1539 && arg1
== current_cpu
->last_open_fd
)
1541 retval
= current_cpu
->last_open_flags
& TARGET_O_ACCMODE
;
1546 /* Because we can't freopen fd:s 0, 1, 2 to mean
1547 something else than stdin, stdout and stderr
1548 (sim/common/syscall.c:cb_syscall special cases fd
1549 0, 1 and 2), we know what flags that we can
1550 sanely return for these fd:s. */
1551 retval
= TARGET_O_RDONLY
;
1554 else if (arg1
== 1 || arg1
== 2)
1556 retval
= TARGET_O_WRONLY
;
1561 /* Nothing else is implemented. */
1563 = cris_unknown_syscall (current_cpu
, pc
,
1564 "Unimplemented %s syscall "
1565 "(fd: 0x%lx: cmd: 0x%lx arg: "
1567 callnum
== TARGET_SYS_fcntl
1568 ? "fcntl" : "fcntl64",
1569 (unsigned long) (USI
) arg1
,
1570 (unsigned long) (USI
) arg2
,
1571 (unsigned long) (USI
) arg3
);
1576 case TARGET_SYS_uname
:
1578 /* Fill in a few constants to appease glibc. */
1579 static char sim_utsname
[6][65] =
1585 "cris", /* Overwritten below. */
1589 /* Having the hardware type in Linux equal to the bfd
1590 printable name is deliberate: if you make config.guess
1591 work on your Linux-type system the usual way, it
1592 probably will; either the bfd printable_name or the
1593 ambiguous arch_name. */
1594 strcpy (sim_utsname
[4], STATE_ARCHITECTURE (sd
)->printable_name
);
1596 if ((s
.write_mem
) (cb
, &s
, arg1
, (const char *) sim_utsname
,
1597 sizeof (sim_utsname
))
1598 != sizeof (sim_utsname
))
1599 retval
= -cb_host_to_target_errno (cb
, EFAULT
);
1605 case TARGET_SYS_geteuid32
:
1606 /* We tell the truth with these. Maybe we shouldn't, but it
1607 should match the "stat" information. */
1608 retval
= geteuid ();
1611 case TARGET_SYS_getuid32
:
1615 case TARGET_SYS_getegid32
:
1616 retval
= getegid ();
1619 case TARGET_SYS_getgid32
:
1623 case TARGET_SYS_brk
:
1624 /* Most often, we just return the argument, like the Linux
1629 retval
= current_cpu
->endbrk
;
1630 else if (arg1
<= current_cpu
->endmem
)
1631 current_cpu
->endbrk
= arg1
;
1634 USI new_end
= (arg1
+ 8191) & ~8191;
1636 /* If the simulator wants to brk more than a certain very
1637 large amount, something is wrong. FIXME: Return an error
1638 or abort? Have command-line selectable? */
1639 if (new_end
- current_cpu
->endmem
> SIM_MAX_ALLOC_CHUNK
)
1641 current_cpu
->endbrk
= current_cpu
->endmem
;
1642 retval
= current_cpu
->endmem
;
1646 sim_core_attach (sd
, NULL
, 0, access_read_write_exec
, 0,
1647 current_cpu
->endmem
,
1648 new_end
- current_cpu
->endmem
,
1650 current_cpu
->endbrk
= arg1
;
1651 current_cpu
->endmem
= new_end
;
1655 case TARGET_SYS_getpid
:
1656 /* Correct until CLONE_THREAD is implemented. */
1657 retval
= current_cpu
->thread_data
== NULL
1659 : TARGET_PID
+ current_cpu
->thread_data
[threadno
].threadid
;
1662 case TARGET_SYS_getppid
:
1663 /* Correct until CLONE_THREAD is implemented. */
1664 retval
= current_cpu
->thread_data
== NULL
1667 + current_cpu
->thread_data
[threadno
].parent_threadid
);
1670 case TARGET_SYS_mmap2
:
1679 /* At 2.6.27, Linux (many (all?) ports, in the mmap2 syscalls)
1680 still masked away this bit, so let's just ignore
1682 flags
&= ~TARGET_MAP_DENYWRITE
;
1684 /* If the simulator wants to mmap more than the very large
1685 limit, something is wrong. FIXME: Return an error or
1686 abort? Have command-line selectable? */
1687 if (len
> SIM_MAX_ALLOC_CHUNK
)
1689 retval
= -cb_host_to_target_errno (cb
, ENOMEM
);
1693 if ((prot
!= (TARGET_PROT_READ
| TARGET_PROT_WRITE
)
1695 != (TARGET_PROT_READ
1697 | TARGET_PROT_EXEC
))
1698 && (prot
!= (TARGET_PROT_READ
| TARGET_PROT_EXEC
))
1699 && prot
!= TARGET_PROT_READ
)
1700 || (flags
!= (TARGET_MAP_ANONYMOUS
| TARGET_MAP_PRIVATE
)
1701 && flags
!= TARGET_MAP_PRIVATE
1702 && flags
!= (TARGET_MAP_ANONYMOUS
1703 | TARGET_MAP_PRIVATE
| TARGET_MAP_FIXED
)
1704 && flags
!= (TARGET_MAP_PRIVATE
| TARGET_MAP_FIXED
)
1705 && flags
!= TARGET_MAP_SHARED
)
1707 && prot
!= TARGET_PROT_READ
1708 && prot
!= (TARGET_PROT_READ
| TARGET_PROT_EXEC
)
1709 && prot
!= (TARGET_PROT_READ
| TARGET_PROT_WRITE
))
1710 || (fd
== (USI
) -1 && pgoff
!= 0)
1711 || (fd
!= (USI
) -1 && (flags
& TARGET_MAP_ANONYMOUS
)))
1714 = cris_unknown_syscall (current_cpu
, pc
,
1715 "Unimplemented mmap2 call "
1716 "(0x%lx, 0x%lx, 0x%lx, "
1717 "0x%lx, 0x%lx, 0x%lx)\n",
1718 (unsigned long) arg1
,
1719 (unsigned long) arg2
,
1720 (unsigned long) arg3
,
1721 (unsigned long) arg4
,
1722 (unsigned long) arg5
,
1723 (unsigned long) arg6
);
1726 else if (fd
!= (USI
) -1)
1733 /* A non-aligned argument is allowed for files. */
1734 USI newlen
= (len
+ 8191) & ~8191;
1736 /* We only support read, read|exec, and read|write,
1737 which we should already have checked. Check again
1739 if (prot
!= TARGET_PROT_READ
1740 && prot
!= (TARGET_PROT_READ
| TARGET_PROT_EXEC
)
1741 && prot
!= (TARGET_PROT_READ
| TARGET_PROT_WRITE
))
1744 if (flags
& TARGET_MAP_FIXED
)
1745 unmap_pages (sd
, ¤t_cpu
->highest_mmapped_page
,
1747 else if (is_mapped (sd
, ¤t_cpu
->highest_mmapped_page
,
1752 = create_map (sd
, ¤t_cpu
->highest_mmapped_page
,
1753 addr
!= 0 || (flags
& TARGET_MAP_FIXED
)
1757 if (newaddr
>= (USI
) -8191)
1760 retval
= -cb_host_to_target_errno (cb
, -(SI
) newaddr
);
1764 /* We were asked for MAP_FIXED, but couldn't. */
1765 if ((flags
& TARGET_MAP_FIXED
) && newaddr
!= addr
)
1768 unmap_pages (sd
, ¤t_cpu
->highest_mmapped_page
,
1770 retval
= -cb_host_to_target_errno (cb
, EINVAL
);
1774 /* Find the current position in the file. */
1775 s
.func
= TARGET_SYS_lseek
;
1779 if (cb_syscall (cb
, &s
) != CB_RC_OK
)
1786 /* Move to the correct offset in the file. */
1787 s
.func
= TARGET_SYS_lseek
;
1789 s
.arg2
= pgoff
*8192;
1791 if (cb_syscall (cb
, &s
) != CB_RC_OK
)
1797 /* Use the standard read callback to read in "len"
1799 s
.func
= TARGET_SYS_read
;
1803 if (cb_syscall (cb
, &s
) != CB_RC_OK
)
1806 /* If the result is a page or more lesser than what
1807 was requested, something went wrong. */
1808 if (len
>= 8192 && (USI
) s
.result
<= len
- 8192)
1811 /* After reading, we need to go back to the previous
1812 position in the file. */
1813 s
.func
= TARGET_SYS_lseek
;
1817 if (cb_syscall (cb
, &s
) != CB_RC_OK
)
1819 if (pos
!= (USI
) s
.result
)
1826 USI newlen
= (len
+ 8191) & ~8191;
1829 if (flags
& TARGET_MAP_FIXED
)
1830 unmap_pages (sd
, ¤t_cpu
->highest_mmapped_page
,
1832 else if (is_mapped (sd
, ¤t_cpu
->highest_mmapped_page
,
1836 newaddr
= create_map (sd
, ¤t_cpu
->highest_mmapped_page
,
1837 addr
!= 0 || (flags
& TARGET_MAP_FIXED
)
1841 if (newaddr
>= (USI
) -8191)
1842 retval
= -cb_host_to_target_errno (cb
, -(SI
) newaddr
);
1846 if ((flags
& TARGET_MAP_FIXED
) && newaddr
!= addr
)
1849 unmap_pages (sd
, ¤t_cpu
->highest_mmapped_page
,
1851 retval
= -cb_host_to_target_errno (cb
, EINVAL
);
1858 case TARGET_SYS_mprotect
:
1860 /* We only cover the case of linuxthreads mprotecting out
1861 its stack guard page and of dynamic loading mprotecting
1862 away the data (for some reason the whole library, then
1863 mprotects away the data part and mmap-FIX:es it again. */
1868 if (prot
!= TARGET_PROT_NONE
1869 || !is_mapped_only (sd
, ¤t_cpu
->highest_mmapped_page
,
1870 addr
, (len
+ 8191) & ~8191))
1873 = cris_unknown_syscall (current_cpu
, pc
,
1874 "Unimplemented mprotect call "
1875 "(0x%lx, 0x%lx, 0x%lx)\n",
1876 (unsigned long) arg1
,
1877 (unsigned long) arg2
,
1878 (unsigned long) arg3
);
1882 /* Just ignore this. We could make this equal to munmap,
1883 but then we'd have to make sure no anon mmaps gets this
1884 address before a subsequent MAP_FIXED mmap intended to
1890 case TARGET_SYS_ioctl
:
1892 /* We support only a very limited functionality: checking
1893 stdout with TCGETS to perform the isatty function. The
1894 TCGETS ioctl isn't actually performed or the result used by
1895 an isatty () caller in a "hello, world" program; only the
1896 return value is then used. Maybe we shouldn't care about
1897 the environment of the simulator regarding isatty, but
1898 that's been working before, in the xsim simulator. */
1899 if (arg2
== TARGET_TCGETS
&& arg1
== 1)
1900 retval
= isatty (1) ? 0 : cb_host_to_target_errno (cb
, EINVAL
);
1902 retval
= -cb_host_to_target_errno (cb
, EINVAL
);
1906 case TARGET_SYS_munmap
:
1911 = unmap_pages (sd
, ¤t_cpu
->highest_mmapped_page
, addr
,
1913 retval
= result
!= 0 ? -cb_host_to_target_errno (cb
, result
) : 0;
1917 case TARGET_SYS_wait4
:
1925 /* FIXME: We're not properly implementing __WCLONE, and we
1926 don't really need the special casing so we might as well
1927 make this general. */
1928 if ((!(pid
== (USI
) -1
1929 && options
== (TARGET___WCLONE
| TARGET_WNOHANG
)
1932 && (options
== TARGET___WCLONE
1933 || options
== TARGET___WALL
)))
1935 || current_cpu
->thread_data
== NULL
)
1938 = cris_unknown_syscall (current_cpu
, pc
,
1939 "Unimplemented wait4 call "
1940 "(0x%lx, 0x%lx, 0x%lx, 0x%lx)\n",
1941 (unsigned long) arg1
,
1942 (unsigned long) arg2
,
1943 (unsigned long) arg3
,
1944 (unsigned long) arg4
);
1948 if (pid
== (USI
) -1)
1949 for (i
= 1; i
< SIM_TARGET_MAX_THREADS
; i
++)
1951 if (current_cpu
->thread_data
[threadno
].threadid
1952 == current_cpu
->thread_data
[i
].parent_threadid
1953 && current_cpu
->thread_data
[i
].threadid
!= 0
1954 && current_cpu
->thread_data
[i
].cpu_context
== NULL
)
1956 /* A zombied child. Get the exit value and clear the
1957 zombied entry so it will be reused. */
1958 sim_core_write_unaligned_4 (current_cpu
, pc
, 0, saddr
,
1960 ->thread_data
[i
].exitval
);
1962 = current_cpu
->thread_data
[i
].threadid
+ TARGET_PID
;
1963 memset (¤t_cpu
->thread_data
[i
], 0,
1964 sizeof (current_cpu
->thread_data
[i
]));
1970 /* We're waiting for a specific PID. If we don't find
1971 it zombied on this run, rerun the syscall. */
1972 for (i
= 1; i
< SIM_TARGET_MAX_THREADS
; i
++)
1973 if (pid
== current_cpu
->thread_data
[i
].threadid
+ TARGET_PID
1974 && current_cpu
->thread_data
[i
].cpu_context
== NULL
)
1977 /* Get the exit value if the caller wants it. */
1978 sim_core_write_unaligned_4 (current_cpu
, pc
, 0,
1985 = current_cpu
->thread_data
[i
].threadid
+ TARGET_PID
;
1986 memset (¤t_cpu
->thread_data
[i
], 0,
1987 sizeof (current_cpu
->thread_data
[i
]));
1992 sim_pc_set (current_cpu
, pc
);
1995 retval
= -cb_host_to_target_errno (cb
, ECHILD
);
2000 case TARGET_SYS_rt_sigaction
:
2008 __sighandler_t sa_handler;
2009 unsigned long sa_flags;
2010 void (*sa_restorer)(void);
2016 sim_core_write_unaligned_4 (current_cpu
, pc
, 0, old_sa
+ 0,
2017 current_cpu
->sighandler
[signum
]);
2018 sim_core_write_unaligned_4 (current_cpu
, pc
, 0, arg3
+ 4, 0);
2019 sim_core_write_unaligned_4 (current_cpu
, pc
, 0, arg3
+ 8, 0);
2021 /* We'll assume _NSIG_WORDS is 2 for the kernel. */
2022 sim_core_write_unaligned_4 (current_cpu
, pc
, 0, arg3
+ 12, 0);
2023 sim_core_write_unaligned_4 (current_cpu
, pc
, 0, arg3
+ 16, 0);
2027 USI target_sa_handler
2028 = sim_core_read_unaligned_4 (current_cpu
, pc
, 0, new_sa
);
2030 = sim_core_read_unaligned_4 (current_cpu
, pc
, 0, new_sa
+ 4);
2031 USI target_sa_restorer
2032 = sim_core_read_unaligned_4 (current_cpu
, pc
, 0, new_sa
+ 8);
2033 USI target_sa_mask_low
2034 = sim_core_read_unaligned_4 (current_cpu
, pc
, 0, new_sa
+ 12);
2035 USI target_sa_mask_high
2036 = sim_core_read_unaligned_4 (current_cpu
, pc
, 0, new_sa
+ 16);
2038 /* We won't interrupt a syscall so we won't restart it,
2039 but a signal(2) call ends up syscalling rt_sigaction
2040 with this flag, so we have to handle it. The
2041 sa_restorer field contains garbage when not
2042 TARGET_SA_RESTORER, so don't look at it. For the
2043 time being, we don't nest sighandlers, so we
2044 ignore the sa_mask, which simplifies things. */
2045 if ((target_sa_flags
!= 0
2046 && target_sa_flags
!= TARGET_SA_RESTART
2047 && target_sa_flags
!= (TARGET_SA_RESTART
|TARGET_SA_SIGINFO
))
2048 || target_sa_handler
== 0)
2051 = cris_unknown_syscall (current_cpu
, pc
,
2052 "Unimplemented rt_sigaction "
2055 "[0x%x, 0x%x, 0x%x, "
2056 "{0x%x, 0x%x}], 0x%lx)\n",
2057 (unsigned long) arg1
,
2058 (unsigned long) arg2
,
2063 target_sa_mask_high
,
2064 (unsigned long) arg3
);
2068 current_cpu
->sighandler
[signum
] = target_sa_handler
;
2070 /* Because we may have unblocked signals, one may now be
2071 pending, if there are threads, that is. */
2072 if (current_cpu
->thread_data
)
2073 current_cpu
->thread_data
[threadno
].sigpending
= 1;
2079 case TARGET_SYS_mremap
:
2085 USI new_addr
= arg5
;
2088 if (new_len
== old_len
)
2089 /* The program and/or library is possibly confused but
2090 this is a valid call. Happens with ipps-1.40 on file
2093 else if (new_len
< old_len
)
2095 /* Shrinking is easy. */
2096 if (unmap_pages (sd
, ¤t_cpu
->highest_mmapped_page
,
2097 addr
+ new_len
, old_len
- new_len
) != 0)
2098 retval
= -cb_host_to_target_errno (cb
, EINVAL
);
2102 else if (! is_mapped (sd
, ¤t_cpu
->highest_mmapped_page
,
2103 addr
+ old_len
, new_len
- old_len
))
2105 /* If the extension isn't mapped, we can just add it. */
2107 = create_map (sd
, ¤t_cpu
->highest_mmapped_page
,
2108 addr
+ old_len
, new_len
- old_len
);
2110 if (mapped_addr
> (USI
) -8192)
2111 retval
= -cb_host_to_target_errno (cb
, -(SI
) mapped_addr
);
2115 else if (flags
& TARGET_MREMAP_MAYMOVE
)
2117 /* Create a whole new map and copy the contents
2118 block-by-block there. We ignore the new_addr argument
2121 USI prev_addr
= addr
;
2122 USI prev_len
= old_len
;
2125 = create_map (sd
, ¤t_cpu
->highest_mmapped_page
,
2128 if (mapped_addr
> (USI
) -8192)
2130 retval
= -cb_host_to_target_errno (cb
, -(SI
) new_addr
);
2134 retval
= mapped_addr
;
2137 old_len
-= 8192, mapped_addr
+= 8192, addr
+= 8192)
2139 if (sim_core_read_buffer (sd
, current_cpu
, read_map
, buf
,
2141 || sim_core_write_buffer (sd
, current_cpu
, 0, buf
,
2142 mapped_addr
, 8192) != 8192)
2146 if (unmap_pages (sd
, ¤t_cpu
->highest_mmapped_page
,
2147 prev_addr
, prev_len
) != 0)
2151 retval
= -cb_host_to_target_errno (cb
, -ENOMEM
);
2155 case TARGET_SYS_poll
:
2157 int npollfds
= arg2
;
2173 /* Check that this is the expected poll call from
2174 linuxthreads/manager.c; we don't support anything else.
2175 Remember, fd == 0 isn't supported. */
2177 || ((fd
= sim_core_read_unaligned_4 (current_cpu
, pc
,
2179 || ((events
= sim_core_read_unaligned_2 (current_cpu
, pc
,
2182 || ((cb
->to_fstat
) (cb
, fd
, &buf
) != 0
2183 || (buf
.st_mode
& S_IFIFO
) == 0)
2184 || current_cpu
->thread_data
== NULL
)
2187 = cris_unknown_syscall (current_cpu
, pc
,
2188 "Unimplemented poll syscall "
2189 "(0x%lx: [0x%x, 0x%x, x], "
2191 (unsigned long) arg1
, fd
, events
,
2192 (unsigned long) arg2
,
2193 (unsigned long) arg3
);
2199 /* Iterate over threads; find a marker that a writer is
2200 sleeping, waiting for a reader. */
2201 for (i
= 0; i
< SIM_TARGET_MAX_THREADS
; i
++)
2202 if (current_cpu
->thread_data
[i
].cpu_context
!= NULL
2203 && current_cpu
->thread_data
[i
].pipe_read_fd
== fd
)
2205 revents
= TARGET_POLLIN
;
2210 /* Timeout decreases with whatever time passed between the
2211 last syscall and this. That's not exactly right for the
2212 first call, but it's close enough that it isn't
2213 worthwhile to complicate matters by making that a special
2216 -= (TARGET_TIME_MS (current_cpu
)
2217 - (current_cpu
->thread_data
[threadno
].last_execution
));
2219 /* Arrange to repeat this syscall until timeout or event,
2220 decreasing timeout at each iteration. */
2221 if (timeout
> 0 && revents
== 0)
2223 bfd_byte timeout_buf
[4];
2225 bfd_putl32 (timeout
, timeout_buf
);
2226 (*CPU_REG_STORE (current_cpu
)) (current_cpu
,
2227 H_GR_R12
, timeout_buf
, 4);
2228 sim_pc_set (current_cpu
, pc
);
2233 sim_core_write_unaligned_2 (current_cpu
, pc
, 0, ufds
+ 4 + 2,
2238 case TARGET_SYS_time
:
2240 retval
= (int) (*cb
->time
) (cb
);
2242 /* At time of this writing, CB_SYSCALL_time doesn't do the
2243 part of setting *arg1 to the return value. */
2245 sim_core_write_unaligned_4 (current_cpu
, pc
, 0, arg1
, retval
);
2249 case TARGET_SYS_gettimeofday
:
2252 USI ts
= TARGET_TIME (current_cpu
);
2253 USI tms
= TARGET_TIME_MS (current_cpu
);
2255 /* First dword is seconds since TARGET_EPOCH. */
2256 sim_core_write_unaligned_4 (current_cpu
, pc
, 0, arg1
, ts
);
2258 /* Second dword is microseconds. */
2259 sim_core_write_unaligned_4 (current_cpu
, pc
, 0, arg1
+ 4,
2260 (tms
% 1000) * 1000);
2264 /* Time-zone info is always cleared. */
2265 sim_core_write_unaligned_4 (current_cpu
, pc
, 0, arg2
, 0);
2266 sim_core_write_unaligned_4 (current_cpu
, pc
, 0, arg2
+ 4, 0);
2271 case TARGET_SYS_llseek
:
2273 /* If it fits, tweak parameters to fit the "generic" 32-bit
2274 lseek and use that. */
2282 if (!((offs_hi
== 0 && offs_lo
>= 0)
2283 || (offs_hi
== -1 && offs_lo
< 0)))
2286 = cris_unknown_syscall (current_cpu
, pc
,
2287 "Unimplemented llseek offset,"
2288 " fd %d: 0x%x:0x%x\n",
2289 fd
, (unsigned) arg2
,
2294 s
.func
= TARGET_SYS_lseek
;
2297 if (cb_syscall (cb
, &s
) != CB_RC_OK
)
2299 sim_io_eprintf (sd
, "Break 13: invalid %d? Returned %ld\n", callnum
,
2301 sim_engine_halt (sd
, current_cpu
, NULL
, pc
, sim_stopped
, SIM_SIGILL
);
2304 retval
= -s
.errcode
;
2307 sim_core_write_unaligned_4 (current_cpu
, pc
, 0, resultp
,
2309 sim_core_write_unaligned_4 (current_cpu
, pc
, 0, resultp
+ 4,
2310 s
.result
< 0 ? -1 : 0);
2315 /* ssize_t writev(int fd, const struct iovec *iov, int iovcnt);
2318 void *iov_base; Starting address
2319 size_t iov_len; Number of bytes to transfer
2321 case TARGET_SYS_writev
:
2329 /* We'll ignore strict error-handling and just do multiple write calls. */
2330 for (i
= 0; i
< iovcnt
; i
++)
2334 = sim_core_read_unaligned_4 (current_cpu
, pc
, 0,
2337 = sim_core_read_unaligned_4 (current_cpu
, pc
, 0,
2340 s
.func
= TARGET_SYS_write
;
2345 if (cb_syscall (cb
, &s
) != CB_RC_OK
)
2347 sysret
= s
.result
== -1 ? -s
.errcode
: s
.result
;
2349 if (sysret
!= iov_len
)
2364 /* This one does have a generic callback function, but at the time
2365 of this writing, cb_syscall does not have code for it, and we
2366 need target-specific code for the threads implementation
2368 case TARGET_SYS_kill
:
2375 /* At kill(2), glibc sets signal masks such that the thread
2376 machinery is initialized. Still, there is and was only
2378 if (current_cpu
->max_threadid
== 0)
2380 if (pid
!= TARGET_PID
)
2382 retval
= -cb_host_to_target_errno (cb
, EPERM
);
2386 /* FIXME: Signal infrastructure (target-to-sim mapping). */
2387 if (sig
== TARGET_SIGABRT
)
2388 /* A call "abort ()", i.e. "kill (getpid(), SIGABRT)" is
2389 the end-point for failing GCC test-cases. */
2390 sim_engine_halt (sd
, current_cpu
, NULL
, pc
, sim_stopped
,
2394 sim_io_eprintf (sd
, "Unimplemented signal: %d\n", sig
);
2395 sim_engine_halt (sd
, current_cpu
, NULL
, pc
, sim_stopped
,
2399 /* This will not be reached. */
2403 retval
= deliver_signal (current_cpu
, sig
, pid
);
2407 case TARGET_SYS_rt_sigprocmask
:
2414 if (how
!= TARGET_SIG_BLOCK
2415 && how
!= TARGET_SIG_SETMASK
2416 && how
!= TARGET_SIG_UNBLOCK
)
2419 = cris_unknown_syscall (current_cpu
, pc
,
2420 "Unimplemented rt_sigprocmask "
2421 "syscall (0x%x, 0x%x, 0x%x)\n",
2429 = sim_core_read_unaligned_4 (current_cpu
, pc
, 0,
2432 = sim_core_read_unaligned_4 (current_cpu
, pc
, 0,
2435 /* The sigmask is kept in the per-thread data, so we may
2436 need to create the first one. */
2437 if (current_cpu
->thread_data
== NULL
)
2438 make_first_thread (current_cpu
);
2440 if (how
== TARGET_SIG_SETMASK
)
2441 for (i
= 0; i
< 64; i
++)
2442 current_cpu
->thread_data
[threadno
].sigdata
[i
].blocked
= 0;
2444 for (i
= 0; i
< 32; i
++)
2445 if ((set_low
& (1 << i
)))
2446 current_cpu
->thread_data
[threadno
].sigdata
[i
+ 1].blocked
2447 = (how
!= TARGET_SIG_UNBLOCK
);
2449 for (i
= 0; i
< 31; i
++)
2450 if ((set_high
& (1 << i
)))
2451 current_cpu
->thread_data
[threadno
].sigdata
[i
+ 33].blocked
2452 = (how
!= TARGET_SIG_UNBLOCK
);
2454 /* The mask changed, so a signal may be unblocked for
2456 current_cpu
->thread_data
[threadno
].sigpending
= 1;
2464 for (i
= 0; i
< 32; i
++)
2465 if (current_cpu
->thread_data
[threadno
]
2466 .sigdata
[i
+ 1].blocked
)
2468 for (i
= 0; i
< 31; i
++)
2469 if (current_cpu
->thread_data
[threadno
]
2470 .sigdata
[i
+ 33].blocked
)
2473 sim_core_write_unaligned_4 (current_cpu
, pc
, 0, oldsetp
+ 0, set_low
);
2474 sim_core_write_unaligned_4 (current_cpu
, pc
, 0, oldsetp
+ 4, set_high
);
2481 case TARGET_SYS_sigreturn
:
2485 int was_sigsuspended
;
2487 if (current_cpu
->thread_data
== NULL
2488 /* The CPU context is saved with the simulator data, not
2489 on the stack as in the real world. */
2490 || (current_cpu
->thread_data
[threadno
].cpu_context_atsignal
2494 = cris_unknown_syscall (current_cpu
, pc
,
2495 "Invalid sigreturn syscall: "
2496 "no signal handler active "
2497 "(0x%lx, 0x%lx, 0x%lx, 0x%lx, "
2499 (unsigned long) arg1
,
2500 (unsigned long) arg2
,
2501 (unsigned long) arg3
,
2502 (unsigned long) arg4
,
2503 (unsigned long) arg5
,
2504 (unsigned long) arg6
);
2509 = current_cpu
->thread_data
[threadno
].sigsuspended
;
2511 /* Restore the sigmask, either from the stack copy made when
2512 the sighandler was called, or from the saved state
2513 specifically for sigsuspend(2). */
2514 if (was_sigsuspended
)
2516 current_cpu
->thread_data
[threadno
].sigsuspended
= 0;
2517 for (i
= 0; i
< 64; i
++)
2518 current_cpu
->thread_data
[threadno
].sigdata
[i
].blocked
2519 = current_cpu
->thread_data
[threadno
]
2520 .sigdata
[i
].blocked_suspendsave
;
2528 (*CPU_REG_FETCH (current_cpu
)) (current_cpu
,
2529 H_GR_SP
, regbuf
, 4);
2530 sp
= bfd_getl32 (regbuf
);
2532 = sim_core_read_unaligned_4 (current_cpu
, pc
, 0, sp
);
2534 = sim_core_read_unaligned_4 (current_cpu
, pc
, 0, sp
+ 4);
2536 for (i
= 0; i
< 32; i
++)
2537 current_cpu
->thread_data
[threadno
].sigdata
[i
+ 1].blocked
2538 = (set_low
& (1 << i
)) != 0;
2539 for (i
= 0; i
< 31; i
++)
2540 current_cpu
->thread_data
[threadno
].sigdata
[i
+ 33].blocked
2541 = (set_high
& (1 << i
)) != 0;
2544 /* The mask changed, so a signal may be unblocked for
2546 current_cpu
->thread_data
[threadno
].sigpending
= 1;
2548 memcpy (¤t_cpu
->cpu_data_placeholder
,
2549 current_cpu
->thread_data
[threadno
].cpu_context_atsignal
,
2550 current_cpu
->thread_cpu_data_size
);
2551 free (current_cpu
->thread_data
[threadno
].cpu_context_atsignal
);
2552 current_cpu
->thread_data
[threadno
].cpu_context_atsignal
= NULL
;
2554 /* The return value must come from the saved R10. */
2555 (*CPU_REG_FETCH (current_cpu
)) (current_cpu
, H_GR_R10
, regbuf
, 4);
2556 retval
= bfd_getl32 (regbuf
);
2558 /* We must also break the "sigsuspension loop". */
2559 if (was_sigsuspended
)
2560 sim_pc_set (current_cpu
, sim_pc_get (current_cpu
) + 2);
2564 case TARGET_SYS_rt_sigsuspend
:
2572 = cris_unknown_syscall (current_cpu
, pc
,
2573 "Unimplemented rt_sigsuspend syscall"
2574 " arguments (0x%lx, 0x%lx)\n",
2575 (unsigned long) arg1
,
2576 (unsigned long) arg2
);
2580 /* Don't change the signal mask if we're already in
2581 sigsuspend state (i.e. this syscall is a rerun). */
2582 else if (!current_cpu
->thread_data
[threadno
].sigsuspended
)
2585 = sim_core_read_unaligned_4 (current_cpu
, pc
, 0,
2588 = sim_core_read_unaligned_4 (current_cpu
, pc
, 0,
2592 /* Save the current sigmask and insert the user-supplied
2594 for (i
= 0; i
< 32; i
++)
2596 current_cpu
->thread_data
[threadno
]
2597 .sigdata
[i
+ 1].blocked_suspendsave
2598 = current_cpu
->thread_data
[threadno
]
2599 .sigdata
[i
+ 1].blocked
;
2601 current_cpu
->thread_data
[threadno
]
2602 .sigdata
[i
+ 1].blocked
= (set_low
& (1 << i
)) != 0;
2604 for (i
= 0; i
< 31; i
++)
2606 current_cpu
->thread_data
[threadno
]
2607 .sigdata
[i
+ 33].blocked_suspendsave
2608 = current_cpu
->thread_data
[threadno
]
2609 .sigdata
[i
+ 33].blocked
;
2610 current_cpu
->thread_data
[threadno
]
2611 .sigdata
[i
+ 33].blocked
= (set_high
& (1 << i
)) != 0;
2614 current_cpu
->thread_data
[threadno
].sigsuspended
= 1;
2616 /* The mask changed, so a signal may be unblocked for
2618 current_cpu
->thread_data
[threadno
].sigpending
= 1;
2621 /* Because we don't use arg1 (newsetp) when this syscall is
2622 rerun, it doesn't matter that we overwrite it with the
2623 (constant) return value. */
2624 retval
= -cb_host_to_target_errno (cb
, EINTR
);
2625 sim_pc_set (current_cpu
, pc
);
2629 /* Add case labels here for other syscalls using the 32-bit
2630 "struct stat", provided they have a corresponding simulator
2631 function of course. */
2632 case TARGET_SYS_stat
:
2633 case TARGET_SYS_fstat
:
2635 /* As long as the infrastructure doesn't cache anything
2636 related to the stat mapping, this trick gets us a dual
2637 "struct stat"-type mapping in the least error-prone way. */
2638 const char *saved_map
= cb
->stat_map
;
2639 CB_TARGET_DEFS_MAP
*saved_syscall_map
= cb
->syscall_map
;
2641 cb
->syscall_map
= (CB_TARGET_DEFS_MAP
*) syscall_stat32_map
;
2642 cb
->stat_map
= stat32_map
;
2644 if (cb_syscall (cb
, &s
) != CB_RC_OK
)
2647 sim_engine_halt (sd
, current_cpu
, NULL
, pc
, sim_stopped
,
2650 retval
= s
.result
== -1 ? -s
.errcode
: s
.result
;
2652 cb
->stat_map
= saved_map
;
2653 cb
->syscall_map
= saved_syscall_map
;
2657 case TARGET_SYS_getcwd
:
2662 char *cwd
= xmalloc (SIM_PATHMAX
);
2663 if (cwd
!= getcwd (cwd
, SIM_PATHMAX
))
2666 /* FIXME: When and if we support chdir, we need something
2667 a bit more elaborate. */
2668 if (simulator_sysroot
[0] != '\0')
2671 retval
= -cb_host_to_target_errno (cb
, ERANGE
);
2672 if (strlen (cwd
) + 1 <= size
)
2674 retval
= strlen (cwd
) + 1;
2675 if (sim_core_write_buffer (sd
, current_cpu
, 0, cwd
,
2677 != (unsigned int) retval
)
2678 retval
= -cb_host_to_target_errno (cb
, EFAULT
);
2684 case TARGET_SYS_access
:
2688 char *pbuf
= xmalloc (SIM_PATHMAX
);
2693 if (sim_core_read_unaligned_1 (current_cpu
, pc
, 0, path
) == '/')
2695 strcpy (pbuf
, simulator_sysroot
);
2696 o
+= strlen (simulator_sysroot
);
2699 for (i
= 0; i
+ o
< SIM_PATHMAX
; i
++)
2702 = sim_core_read_unaligned_1 (current_cpu
, pc
, 0, path
+ i
);
2703 if (pbuf
[i
+ o
] == 0)
2707 if (i
+ o
== SIM_PATHMAX
)
2709 retval
= -cb_host_to_target_errno (cb
, ENAMETOOLONG
);
2713 /* Assert that we don't get calls for files for which we
2714 don't have support. */
2715 if (strncmp (pbuf
+ strlen (simulator_sysroot
),
2718 #define X_AFLAG(x) if (mode & TARGET_ ## x) hmode |= x
2725 if (access (pbuf
, hmode
) != 0)
2726 retval
= -cb_host_to_target_errno (cb
, errno
);
2734 case TARGET_SYS_readlink
:
2739 char *pbuf
= xmalloc (SIM_PATHMAX
);
2740 char *lbuf
= xmalloc (SIM_PATHMAX
);
2741 char *lbuf_alloc
= lbuf
;
2746 if (sim_core_read_unaligned_1 (current_cpu
, pc
, 0, path
) == '/')
2748 strcpy (pbuf
, simulator_sysroot
);
2749 o
+= strlen (simulator_sysroot
);
2752 for (i
= 0; i
+ o
< SIM_PATHMAX
; i
++)
2755 = sim_core_read_unaligned_1 (current_cpu
, pc
, 0, path
+ i
);
2756 if (pbuf
[i
+ o
] == 0)
2760 if (i
+ o
== SIM_PATHMAX
)
2762 retval
= -cb_host_to_target_errno (cb
, ENAMETOOLONG
);
2766 /* Intervene calls for certain files expected in the target
2767 proc file system. */
2768 if (strcmp (pbuf
+ strlen (simulator_sysroot
),
2769 "/proc/" XSTRING (TARGET_PID
) "/exe") == 0)
2772 = (STATE_PROG_ARGV (sd
) != NULL
2773 ? *STATE_PROG_ARGV (sd
) : NULL
);
2775 if (argv0
== NULL
|| *argv0
== '.')
2778 = cris_unknown_syscall (current_cpu
, pc
,
2779 "Unimplemented readlink syscall "
2780 "(0x%lx: [\"%s\"], 0x%lx)\n",
2781 (unsigned long) arg1
, pbuf
,
2782 (unsigned long) arg2
);
2785 else if (*argv0
== '/')
2787 if (strncmp (simulator_sysroot
, argv0
,
2788 strlen (simulator_sysroot
)) == 0)
2789 argv0
+= strlen (simulator_sysroot
);
2791 strcpy (lbuf
, argv0
);
2792 nchars
= strlen (argv0
) + 1;
2796 if (getcwd (lbuf
, SIM_PATHMAX
) != NULL
2797 && strlen (lbuf
) + 2 + strlen (argv0
) < SIM_PATHMAX
)
2799 if (strncmp (simulator_sysroot
, lbuf
,
2800 strlen (simulator_sysroot
)) == 0)
2801 lbuf
+= strlen (simulator_sysroot
);
2804 strcat (lbuf
, argv0
);
2805 nchars
= strlen (lbuf
) + 1;
2812 nchars
= readlink (pbuf
, lbuf
, SIM_PATHMAX
);
2814 /* We trust that the readlink result returns a *relative*
2815 link, or one already adjusted for the file-path-prefix.
2816 (We can't generally tell the difference, so we go with
2817 the easiest decision; no adjustment.) */
2821 retval
= -cb_host_to_target_errno (cb
, errno
);
2825 if (bufsiz
< nchars
)
2828 if (sim_core_write_buffer (sd
, current_cpu
, write_map
, lbuf
,
2829 buf
, nchars
) != (unsigned int) nchars
)
2830 retval
= -cb_host_to_target_errno (cb
, EFAULT
);
2839 case TARGET_SYS_sched_getscheduler
:
2843 /* FIXME: Search (other) existing threads. */
2844 if (pid
!= 0 && pid
!= TARGET_PID
)
2845 retval
= -cb_host_to_target_errno (cb
, ESRCH
);
2847 retval
= TARGET_SCHED_OTHER
;
2851 case TARGET_SYS_sched_getparam
:
2857 struct sched_param {
2861 if (pid
!= 0 && pid
!= TARGET_PID
)
2862 retval
= -cb_host_to_target_errno (cb
, ESRCH
);
2865 /* FIXME: Save scheduler setting before threads are
2867 sim_core_write_unaligned_4 (current_cpu
, pc
, 0, paramp
,
2868 current_cpu
->thread_data
!= NULL
2870 ->thread_data
[threadno
]
2878 case TARGET_SYS_sched_setparam
:
2883 if ((pid
!= 0 && pid
!= TARGET_PID
)
2884 || sim_core_read_unaligned_4 (current_cpu
, pc
, 0,
2886 retval
= -cb_host_to_target_errno (cb
, EINVAL
);
2892 case TARGET_SYS_sched_setscheduler
:
2898 if ((pid
!= 0 && pid
!= TARGET_PID
)
2899 || policy
!= TARGET_SCHED_OTHER
2900 || sim_core_read_unaligned_4 (current_cpu
, pc
, 0,
2902 retval
= -cb_host_to_target_errno (cb
, EINVAL
);
2904 /* FIXME: Save scheduler setting to be read in later
2905 sched_getparam calls. */
2910 case TARGET_SYS_sched_yield
:
2911 /* We reschedule to the next thread after a syscall anyway, so
2912 we don't have to do anything here than to set the return
2917 case TARGET_SYS_sched_get_priority_min
:
2918 case TARGET_SYS_sched_get_priority_max
:
2920 retval
= -cb_host_to_target_errno (cb
, EINVAL
);
2925 case TARGET_SYS_ugetrlimit
:
2927 unsigned int curlim
, maxlim
;
2928 if (arg1
!= TARGET_RLIMIT_STACK
&& arg1
!= TARGET_RLIMIT_NOFILE
)
2930 retval
= -cb_host_to_target_errno (cb
, EINVAL
);
2936 unsigned long rlim_cur;
2937 unsigned long rlim_max;
2939 if (arg1
== TARGET_RLIMIT_NOFILE
)
2941 /* Sadly a very low limit. Better not lie, though. */
2942 maxlim
= curlim
= MAX_CALLBACK_FDS
;
2944 else /* arg1 == TARGET_RLIMIT_STACK */
2946 maxlim
= 0xffffffff;
2949 sim_core_write_unaligned_4 (current_cpu
, pc
, 0, arg2
, curlim
);
2950 sim_core_write_unaligned_4 (current_cpu
, pc
, 0, arg2
+ 4, maxlim
);
2955 case TARGET_SYS_setrlimit
:
2956 if (arg1
!= TARGET_RLIMIT_STACK
)
2958 retval
= -cb_host_to_target_errno (cb
, EINVAL
);
2961 /* FIXME: Save values for future ugetrlimit calls. */
2965 /* Provide a very limited subset of the sysctl functions, and
2966 abort for the rest. */
2967 case TARGET_SYS__sysctl
:
2970 struct __sysctl_args {
2977 unsigned long __unused[4];
2979 SI name
= sim_core_read_unaligned_4 (current_cpu
, pc
, 0, arg1
);
2980 SI name0
= name
== 0
2981 ? 0 : sim_core_read_unaligned_4 (current_cpu
, pc
, 0, name
);
2982 SI name1
= name
== 0
2983 ? 0 : sim_core_read_unaligned_4 (current_cpu
, pc
, 0, name
+ 4);
2985 = sim_core_read_unaligned_4 (current_cpu
, pc
, 0, arg1
+ 4);
2987 = sim_core_read_unaligned_4 (current_cpu
, pc
, 0, arg1
+ 8);
2989 = sim_core_read_unaligned_4 (current_cpu
, pc
, 0, arg1
+ 12);
2990 SI oldlen
= oldlenp
== 0
2991 ? 0 : sim_core_read_unaligned_4 (current_cpu
, pc
, 0, oldlenp
);
2993 = sim_core_read_unaligned_4 (current_cpu
, pc
, 0, arg1
+ 16);
2995 = sim_core_read_unaligned_4 (current_cpu
, pc
, 0, arg1
+ 20);
2997 if (name0
== TARGET_CTL_KERN
&& name1
== TARGET_CTL_KERN_VERSION
)
2999 SI to_write
= oldlen
< (SI
) sizeof (TARGET_UTSNAME
)
3000 ? oldlen
: (SI
) sizeof (TARGET_UTSNAME
);
3002 sim_core_write_unaligned_4 (current_cpu
, pc
, 0, oldlenp
,
3003 sizeof (TARGET_UTSNAME
));
3005 if (sim_core_write_buffer (sd
, current_cpu
, write_map
,
3006 TARGET_UTSNAME
, oldval
,
3008 != (unsigned int) to_write
)
3009 retval
= -cb_host_to_target_errno (cb
, EFAULT
);
3016 = cris_unknown_syscall (current_cpu
, pc
,
3017 "Unimplemented _sysctl syscall "
3018 "(0x%lx: [0x%lx, 0x%lx],"
3019 " 0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx)\n",
3020 (unsigned long) name
,
3021 (unsigned long) name0
,
3022 (unsigned long) name1
,
3023 (unsigned long) nlen
,
3024 (unsigned long) oldval
,
3025 (unsigned long) oldlenp
,
3026 (unsigned long) newval
,
3027 (unsigned long) newlen
);
3031 case TARGET_SYS_exit
:
3033 /* Here for all but the last thread. */
3036 = current_cpu
->thread_data
[threadno
].threadid
+ TARGET_PID
;
3038 = (current_cpu
->thread_data
[threadno
].parent_threadid
3040 int exitsig
= current_cpu
->thread_data
[threadno
].exitsig
;
3042 /* Any children are now all orphans. */
3043 for (i
= 0; i
< SIM_TARGET_MAX_THREADS
; i
++)
3044 if (current_cpu
->thread_data
[i
].parent_threadid
3045 == current_cpu
->thread_data
[threadno
].threadid
)
3046 /* Make getppid(2) return 1 for them, poor little ones. */
3047 current_cpu
->thread_data
[i
].parent_threadid
= -TARGET_PID
+ 1;
3049 /* Free the cpu context data. When the parent has received
3050 the exit status, we'll clear the entry too. */
3051 free (current_cpu
->thread_data
[threadno
].cpu_context
);
3052 current_cpu
->thread_data
[threadno
].cpu_context
= NULL
;
3053 current_cpu
->m1threads
--;
3056 sim_io_eprintf (sd
, "Thread %d exited with status %d\n",
3058 sim_engine_halt (sd
, current_cpu
, NULL
, pc
, sim_stopped
,
3062 /* Still, we may want to support non-zero exit values. */
3063 current_cpu
->thread_data
[threadno
].exitval
= arg1
<< 8;
3066 deliver_signal (current_cpu
, exitsig
, ppid
);
3070 case TARGET_SYS_clone
:
3072 int nthreads
= current_cpu
->m1threads
+ 1;
3073 void *thread_cpu_data
;
3074 bfd_byte old_sp_buf
[4];
3076 const bfd_byte zeros
[4] = { 0, 0, 0, 0 };
3079 /* That's right, the syscall clone arguments are reversed
3080 compared to sys_clone notes in clone(2) and compared to
3081 other Linux ports (i.e. it's the same order as in the
3082 clone(2) libcall). */
3086 if (nthreads
== SIM_TARGET_MAX_THREADS
)
3088 retval
= -cb_host_to_target_errno (cb
, EAGAIN
);
3092 /* FIXME: Implement the low byte. */
3093 if ((flags
& ~TARGET_CSIGNAL
) !=
3096 | TARGET_CLONE_FILES
3097 | TARGET_CLONE_SIGHAND
)
3101 = cris_unknown_syscall (current_cpu
, pc
,
3102 "Unimplemented clone syscall "
3104 (unsigned long) arg1
,
3105 (unsigned long) arg2
);
3109 if (current_cpu
->thread_data
== NULL
)
3110 make_first_thread (current_cpu
);
3112 /* The created thread will get the new SP and a cleared R10.
3113 Since it's created out of a copy of the old thread and we
3114 don't have a set-register-function that just take the
3115 cpu_data as a parameter, we set the childs values first,
3116 and write back or overwrite them in the parent after the
3118 (*CPU_REG_FETCH (current_cpu
)) (current_cpu
,
3119 H_GR_SP
, old_sp_buf
, 4);
3120 bfd_putl32 (newsp
, sp_buf
);
3121 (*CPU_REG_STORE (current_cpu
)) (current_cpu
,
3122 H_GR_SP
, sp_buf
, 4);
3123 (*CPU_REG_STORE (current_cpu
)) (current_cpu
,
3124 H_GR_R10
, (bfd_byte
*) zeros
, 4);
3127 ->make_thread_cpu_data
) (current_cpu
,
3128 ¤t_cpu
->cpu_data_placeholder
);
3129 (*CPU_REG_STORE (current_cpu
)) (current_cpu
,
3130 H_GR_SP
, old_sp_buf
, 4);
3132 retval
= ++current_cpu
->max_threadid
+ TARGET_PID
;
3134 /* Find an unused slot. After a few threads have been created
3135 and exited, the array is expected to be a bit fragmented.
3136 We don't reuse the first entry, though, that of the
3138 for (i
= 1; i
< SIM_TARGET_MAX_THREADS
; i
++)
3139 if (current_cpu
->thread_data
[i
].cpu_context
== NULL
3140 /* Don't reuse a zombied entry. */
3141 && current_cpu
->thread_data
[i
].threadid
== 0)
3144 memcpy (¤t_cpu
->thread_data
[i
],
3145 ¤t_cpu
->thread_data
[threadno
],
3146 sizeof (current_cpu
->thread_data
[i
]));
3147 current_cpu
->thread_data
[i
].cpu_context
= thread_cpu_data
;
3148 current_cpu
->thread_data
[i
].cpu_context_atsignal
= NULL
;
3149 current_cpu
->thread_data
[i
].threadid
= current_cpu
->max_threadid
;
3150 current_cpu
->thread_data
[i
].parent_threadid
3151 = current_cpu
->thread_data
[threadno
].threadid
;
3152 current_cpu
->thread_data
[i
].pipe_read_fd
= 0;
3153 current_cpu
->thread_data
[i
].pipe_write_fd
= 0;
3154 current_cpu
->thread_data
[i
].at_syscall
= 0;
3155 current_cpu
->thread_data
[i
].sigpending
= 0;
3156 current_cpu
->thread_data
[i
].sigsuspended
= 0;
3157 current_cpu
->thread_data
[i
].exitsig
= flags
& TARGET_CSIGNAL
;
3158 current_cpu
->m1threads
= nthreads
;
3162 /* Better watch these in case they do something necessary. */
3163 case TARGET_SYS_socketcall
:
3164 retval
= -cb_host_to_target_errno (cb
, ENOSYS
);
3167 case TARGET_SYS_set_thread_area
:
3168 /* Do the same error check as Linux. */
3171 retval
= -cb_host_to_target_errno (cb
, EINVAL
);
3174 (*current_cpu
->set_target_thread_data
) (current_cpu
, arg1
);
3178 unimplemented_syscall
:
3181 = cris_unknown_syscall (current_cpu
, pc
,
3182 "Unimplemented syscall: %d "
3183 "(0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x)\n",
3184 callnum
, arg1
, arg2
, arg3
, arg4
, arg5
,
3189 /* Minimal support for fcntl F_GETFL as used in open+fdopen. */
3190 if (callnum
== TARGET_SYS_open
)
3192 current_cpu
->last_open_fd
= retval
;
3193 current_cpu
->last_open_flags
= arg2
;
3196 current_cpu
->last_syscall
= callnum
;
3198 /* A system call is a rescheduling point. For the time being, we don't
3199 reschedule anywhere else. */
3200 if (current_cpu
->m1threads
!= 0
3201 /* We need to schedule off from an exiting thread that is the
3203 || (current_cpu
->thread_data
!= NULL
3204 && current_cpu
->thread_data
[threadno
].cpu_context
== NULL
))
3206 bfd_byte retval_buf
[4];
3208 current_cpu
->thread_data
[threadno
].last_execution
3209 = TARGET_TIME_MS (current_cpu
);
3210 bfd_putl32 (retval
, retval_buf
);
3211 (*CPU_REG_STORE (current_cpu
)) (current_cpu
, H_GR_R10
, retval_buf
, 4);
3213 current_cpu
->thread_data
[threadno
].at_syscall
= 1;
3214 reschedule (current_cpu
);
3216 (*CPU_REG_FETCH (current_cpu
)) (current_cpu
, H_GR_R10
, retval_buf
, 4);
3217 retval
= bfd_getl32 (retval_buf
);
3223 /* Callback from simulator write saying that the pipe at (reader, writer)
3224 is now non-empty (so the writer should wait until the pipe is empty, at
3225 least not write to this or any other pipe). Simplest is to just wait
3226 until the pipe is empty. */
3229 cris_pipe_nonempty (host_callback
*cb ATTRIBUTE_UNUSED
,
3230 int reader
, int writer
)
3232 SIM_CPU
*cpu
= current_cpu_for_cb_callback
;
3233 const bfd_byte zeros
[4] = { 0, 0, 0, 0 };
3235 /* It's the current thread: we just have to re-run the current
3236 syscall instruction (presumably "break 13") and change the syscall
3237 to the special simulator-wait code. Oh, and set a marker that
3238 we're waiting, so we can disambiguate the special call from a
3241 This function may be called multiple times between cris_pipe_empty,
3242 but we must avoid e.g. decreasing PC every time. Check fd markers
3244 if (cpu
->thread_data
== NULL
)
3246 sim_io_eprintf (CPU_STATE (cpu
),
3247 "Terminating simulation due to writing pipe rd:wr %d:%d"
3248 " from one single thread\n", reader
, writer
);
3249 sim_engine_halt (CPU_STATE (cpu
), cpu
,
3250 NULL
, sim_pc_get (cpu
), sim_stopped
, SIM_SIGILL
);
3252 else if (cpu
->thread_data
[cpu
->threadno
].pipe_write_fd
== 0)
3254 cpu
->thread_data
[cpu
->threadno
].pipe_write_fd
= writer
;
3255 cpu
->thread_data
[cpu
->threadno
].pipe_read_fd
= reader
;
3256 /* FIXME: We really shouldn't change registers other than R10 in
3257 syscalls (like R9), here or elsewhere. */
3258 (*CPU_REG_STORE (cpu
)) (cpu
, H_GR_R9
, (bfd_byte
*) zeros
, 4);
3259 sim_pc_set (cpu
, sim_pc_get (cpu
) - 2);
3263 /* Callback from simulator close or read call saying that the pipe at
3264 (reader, writer) is now empty (so the writer can write again, perhaps
3265 leave a waiting state). If there are bytes remaining, they couldn't be
3266 consumed (perhaps due to the pipe closing). */
3269 cris_pipe_empty (host_callback
*cb
,
3274 SIM_CPU
*cpu
= current_cpu_for_cb_callback
;
3275 SIM_DESC sd
= CPU_STATE (current_cpu_for_cb_callback
);
3276 bfd_byte r10_buf
[4];
3278 = cb
->pipe_buffer
[writer
].size
- cb
->pipe_buffer
[reader
].size
;
3280 /* We need to find the thread that waits for this pipe. */
3281 for (i
= 0; i
< SIM_TARGET_MAX_THREADS
; i
++)
3282 if (cpu
->thread_data
[i
].cpu_context
3283 && cpu
->thread_data
[i
].pipe_write_fd
== writer
)
3287 /* Temporarily switch to this cpu context, so we can change the
3288 PC by ordinary calls. */
3290 memcpy (cpu
->thread_data
[cpu
->threadno
].cpu_context
,
3291 &cpu
->cpu_data_placeholder
,
3292 cpu
->thread_cpu_data_size
);
3293 memcpy (&cpu
->cpu_data_placeholder
,
3294 cpu
->thread_data
[i
].cpu_context
,
3295 cpu
->thread_cpu_data_size
);
3297 /* The return value is supposed to contain the number of
3298 written bytes, which is the number of bytes requested and
3299 returned at the write call. You might think the right
3300 thing is to adjust the return-value to be only the
3301 *consumed* number of bytes, but it isn't. We're only
3302 called if the pipe buffer is fully consumed or it is being
3303 closed, possibly with remaining bytes. For the latter
3304 case, the writer is still supposed to see success for
3305 PIPE_BUF bytes (a constant which we happen to know and is
3306 unlikely to change). The return value may also be a
3307 negative number; an error value. This case is covered
3308 because "remaining" is always >= 0. */
3309 (*CPU_REG_FETCH (cpu
)) (cpu
, H_GR_R10
, r10_buf
, 4);
3310 retval
= (int) bfd_getl_signed_32 (r10_buf
);
3311 if (retval
- remaining
> TARGET_PIPE_BUF
)
3313 bfd_putl32 (retval
- remaining
, r10_buf
);
3314 (*CPU_REG_STORE (cpu
)) (cpu
, H_GR_R10
, r10_buf
, 4);
3316 sim_pc_set (cpu
, sim_pc_get (cpu
) + 2);
3317 memcpy (cpu
->thread_data
[i
].cpu_context
,
3318 &cpu
->cpu_data_placeholder
,
3319 cpu
->thread_cpu_data_size
);
3320 memcpy (&cpu
->cpu_data_placeholder
,
3321 cpu
->thread_data
[cpu
->threadno
].cpu_context
,
3322 cpu
->thread_cpu_data_size
);
3323 cpu
->thread_data
[i
].pipe_read_fd
= 0;
3324 cpu
->thread_data
[i
].pipe_write_fd
= 0;
3331 /* We have a simulator-specific notion of time. See TARGET_TIME. */
3334 cris_time (host_callback
*cb ATTRIBUTE_UNUSED
)
3336 return TARGET_TIME (current_cpu_for_cb_callback
);
3340 cris_getpid (host_callback
*cb ATTRIBUTE_UNUSED
)
3345 /* Set target-specific callback data. */
3348 cris_set_callbacks (host_callback
*cb
)
3350 /* Yeargh, have to cast away constness to avoid warnings. */
3351 cb
->syscall_map
= (CB_TARGET_DEFS_MAP
*) syscall_map
;
3352 cb
->errno_map
= (CB_TARGET_DEFS_MAP
*) errno_map
;
3354 cb
->getpid
= cris_getpid
;
3356 /* The kernel stat64 layout. If we see a file > 2G, the "long"
3357 parameter to cb_store_target_endian will make st_size negative.
3358 Similarly for st_ino. FIXME: Find a 64-bit type, and use it
3359 *unsigned*, and/or add syntax for signed-ness. */
3360 cb
->stat_map
= stat_map
;
3361 cb
->open_map
= (CB_TARGET_DEFS_MAP
*) open_map
;
3362 cb
->pipe_nonempty
= cris_pipe_nonempty
;
3363 cb
->pipe_empty
= cris_pipe_empty
;
3364 cb
->time
= cris_time
;
3367 /* Process an address exception. */
3370 cris_core_signal (SIM_DESC sd
, SIM_CPU
*current_cpu
, sim_cia cia
,
3371 unsigned int map
, int nr_bytes
, address_word addr
,
3372 transfer_type transfer
, sim_core_signals sig
)
3374 sim_core_signal (sd
, current_cpu
, cia
, map
, nr_bytes
, addr
,