projects / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Updated copyright notices for most files.
[binutils-gdb.git] / sim / cris / traps.c
1 /* CRIS exception, interrupt, and trap (EIT) support
2 Copyright (C) 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
3 Contributed by Axis Communications.
4
5 This file is part of the GNU simulators.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20 #include "sim-main.h"
21 #include "sim-options.h"
22 #include "bfd.h"
23 /* FIXME: get rid of targ-vals.h usage everywhere else. */
24
25 #include <stdarg.h>
26 #ifdef HAVE_ERRNO_H
27 #include <errno.h>
28 #endif
29 #ifdef HAVE_UNISTD_H
30 #include <unistd.h>
31 #endif
32 #ifdef HAVE_FCNTL_H
33 #include <fcntl.h>
34 #endif
35 #ifdef HAVE_SYS_PARAM_H
36 #include <sys/param.h>
37 #endif
38 #ifdef HAVE_SYS_STAT_H
39 #include <sys/stat.h>
40 #endif
41 /* For PATH_MAX, originally. */
42 #ifdef HAVE_LIMITS_H
43 #include <limits.h>
44 #endif
45
46 /* From ld/sysdep.h. */
47 #ifdef PATH_MAX
48 # define SIM_PATHMAX PATH_MAX
49 #else
50 # ifdef MAXPATHLEN
51 # define SIM_PATHMAX MAXPATHLEN
52 # else
53 # define SIM_PATHMAX 1024
54 # endif
55 #endif
56
57 /* The verbatim values are from asm-cris/unistd.h. */
58
59 #define TARGET_SYS_exit 1
60 #define TARGET_SYS_read 3
61 #define TARGET_SYS_write 4
62 #define TARGET_SYS_open 5
63 #define TARGET_SYS_close 6
64 #define TARGET_SYS_unlink 10
65 #define TARGET_SYS_time 13
66 #define TARGET_SYS_lseek 19
67 #define TARGET_SYS_getpid 20
68 #define TARGET_SYS_kill 37
69 #define TARGET_SYS_rename 38
70 #define TARGET_SYS_pipe 42
71 #define TARGET_SYS_brk 45
72 #define TARGET_SYS_ioctl 54
73 #define TARGET_SYS_fcntl 55
74 #define TARGET_SYS_getppid 64
75 #define TARGET_SYS_setrlimit 75
76 #define TARGET_SYS_gettimeofday 78
77 #define TARGET_SYS_readlink 85
78 #define TARGET_SYS_munmap 91
79 #define TARGET_SYS_truncate 92
80 #define TARGET_SYS_ftruncate 93
81 #define TARGET_SYS_socketcall 102
82 #define TARGET_SYS_stat 106
83 #define TARGET_SYS_fstat 108
84 #define TARGET_SYS_wait4 114
85 #define TARGET_SYS_sigreturn 119
86 #define TARGET_SYS_clone 120
87 #define TARGET_SYS_uname 122
88 #define TARGET_SYS_mprotect 125
89 #define TARGET_SYS_llseek 140
90 #define TARGET_SYS__sysctl 149
91 #define TARGET_SYS_sched_setparam 154
92 #define TARGET_SYS_sched_getparam 155
93 #define TARGET_SYS_sched_setscheduler 156
94 #define TARGET_SYS_sched_getscheduler 157
95 #define TARGET_SYS_sched_yield 158
96 #define TARGET_SYS_sched_get_priority_max 159
97 #define TARGET_SYS_sched_get_priority_min 160
98 #define TARGET_SYS_mremap 163
99 #define TARGET_SYS_poll 168
100 #define TARGET_SYS_rt_sigaction 174
101 #define TARGET_SYS_rt_sigprocmask 175
102 #define TARGET_SYS_rt_sigsuspend 179
103 #define TARGET_SYS_getcwd 183
104 #define TARGET_SYS_ugetrlimit 191
105 #define TARGET_SYS_mmap2 192
106 #define TARGET_SYS_stat64 195
107 #define TARGET_SYS_lstat64 196
108 #define TARGET_SYS_fstat64 197
109 #define TARGET_SYS_geteuid32 201
110 #define TARGET_SYS_getuid32 199
111 #define TARGET_SYS_getegid32 202
112 #define TARGET_SYS_getgid32 200
113 #define TARGET_SYS_fcntl64 221
114
115 #define TARGET_PROT_READ 0x1
116 #define TARGET_PROT_WRITE 0x2
117 #define TARGET_PROT_EXEC 0x4
118 #define TARGET_PROT_NONE 0x0
119
120 #define TARGET_MAP_SHARED 0x01
121 #define TARGET_MAP_PRIVATE 0x02
122 #define TARGET_MAP_TYPE 0x0f
123 #define TARGET_MAP_FIXED 0x10
124 #define TARGET_MAP_ANONYMOUS 0x20
125
126 #define TARGET_CTL_KERN 1
127 #define TARGET_CTL_VM 2
128 #define TARGET_CTL_NET 3
129 #define TARGET_CTL_PROC 4
130 #define TARGET_CTL_FS 5
131 #define TARGET_CTL_DEBUG 6
132 #define TARGET_CTL_DEV 7
133 #define TARGET_CTL_BUS 8
134 #define TARGET_CTL_ABI 9
135
136 #define TARGET_CTL_KERN_VERSION 4
137
138 /* linux/mman.h */
139 #define TARGET_MREMAP_MAYMOVE 1
140 #define TARGET_MREMAP_FIXED 2
141
142 #define TARGET_TCGETS 0x5401
143
144 #define TARGET_UTSNAME "#38 Sun Apr 1 00:00:00 MET 2001"
145
146 /* Seconds since the above date + 10 minutes. */
147 #define TARGET_EPOCH 986080200
148
149 /* Milliseconds since start of run. We use the number of syscalls to
150 avoid introducing noise in the execution time. */
151 #define TARGET_TIME_MS(cpu) ((cpu)->syscalls)
152
153 /* Seconds as in time(2). */
154 #define TARGET_TIME(cpu) (TARGET_EPOCH + TARGET_TIME_MS (cpu) / 1000)
155
156 #define TARGET_SCHED_OTHER 0
157
158 #define TARGET_RLIMIT_STACK 3
159 #define TARGET_RLIMIT_NOFILE 7
160
161 #define SIM_TARGET_MAX_THREADS 64
162 #define SIM_MAX_ALLOC_CHUNK (512*1024*1024)
163
164 /* From linux/sched.h. */
165 #define TARGET_CSIGNAL 0x000000ff
166 #define TARGET_CLONE_VM 0x00000100
167 #define TARGET_CLONE_FS 0x00000200
168 #define TARGET_CLONE_FILES 0x00000400
169 #define TARGET_CLONE_SIGHAND 0x00000800
170 #define TARGET_CLONE_PID 0x00001000
171 #define TARGET_CLONE_PTRACE 0x00002000
172 #define TARGET_CLONE_VFORK 0x00004000
173 #define TARGET_CLONE_PARENT 0x00008000
174 #define TARGET_CLONE_THREAD 0x00010000
175 #define TARGET_CLONE_SIGNAL (TARGET_CLONE_SIGHAND | TARGET_CLONE_THREAD)
176
177 /* From asm-cris/poll.h. */
178 #define TARGET_POLLIN 1
179
180 /* From asm-cris/signal.h. */
181 #define TARGET_SIG_BLOCK 0
182 #define TARGET_SIG_UNBLOCK 1
183 #define TARGET_SIG_SETMASK 2
184
185 #define TARGET_SIG_DFL 0
186 #define TARGET_SIG_IGN 1
187 #define TARGET_SIG_ERR ((USI)-1)
188
189 #define TARGET_SIGHUP 1
190 #define TARGET_SIGINT 2
191 #define TARGET_SIGQUIT 3
192 #define TARGET_SIGILL 4
193 #define TARGET_SIGTRAP 5
194 #define TARGET_SIGABRT 6
195 #define TARGET_SIGIOT 6
196 #define TARGET_SIGBUS 7
197 #define TARGET_SIGFPE 8
198 #define TARGET_SIGKILL 9
199 #define TARGET_SIGUSR1 10
200 #define TARGET_SIGSEGV 11
201 #define TARGET_SIGUSR2 12
202 #define TARGET_SIGPIPE 13
203 #define TARGET_SIGALRM 14
204 #define TARGET_SIGTERM 15
205 #define TARGET_SIGSTKFLT 16
206 #define TARGET_SIGCHLD 17
207 #define TARGET_SIGCONT 18
208 #define TARGET_SIGSTOP 19
209 #define TARGET_SIGTSTP 20
210 #define TARGET_SIGTTIN 21
211 #define TARGET_SIGTTOU 22
212 #define TARGET_SIGURG 23
213 #define TARGET_SIGXCPU 24
214 #define TARGET_SIGXFSZ 25
215 #define TARGET_SIGVTALRM 26
216 #define TARGET_SIGPROF 27
217 #define TARGET_SIGWINCH 28
218 #define TARGET_SIGIO 29
219 #define TARGET_SIGPOLL SIGIO
220 /* Actually commented out in the kernel header. */
221 #define TARGET_SIGLOST 29
222 #define TARGET_SIGPWR 30
223 #define TARGET_SIGSYS 31
224
225 /* From include/asm-cris/signal.h. */
226 #define TARGET_SA_NOCLDSTOP 0x00000001
227 #define TARGET_SA_NOCLDWAIT 0x00000002 /* not supported yet */
228 #define TARGET_SA_SIGINFO 0x00000004
229 #define TARGET_SA_ONSTACK 0x08000000
230 #define TARGET_SA_RESTART 0x10000000
231 #define TARGET_SA_NODEFER 0x40000000
232 #define TARGET_SA_RESETHAND 0x80000000
233 #define TARGET_SA_INTERRUPT 0x20000000 /* dummy -- ignored */
234 #define TARGET_SA_RESTORER 0x04000000
235
236 /* From linux/wait.h. */
237 #define TARGET_WNOHANG 1
238 #define TARGET_WUNTRACED 2
239 #define TARGET___WNOTHREAD 0x20000000
240 #define TARGET___WALL 0x40000000
241 #define TARGET___WCLONE 0x80000000
242
243 /* From linux/limits.h. */
244 #define TARGET_PIPE_BUF 4096
245
246 static const char stat_map[] =
247 "st_dev,2:space,10:space,4:st_mode,4:st_nlink,4:st_uid,4"
248 ":st_gid,4:st_rdev,2:space,10:st_size,8:st_blksize,4:st_blocks,4"
249 ":space,4:st_atime,4:space,4:st_mtime,4:space,4:st_ctime,4:space,4"
250 ":st_ino,8";
251
252 static const CB_TARGET_DEFS_MAP syscall_map[] =
253 {
254 { CB_SYS_open, TARGET_SYS_open },
255 { CB_SYS_close, TARGET_SYS_close },
256 { CB_SYS_read, TARGET_SYS_read },
257 { CB_SYS_write, TARGET_SYS_write },
258 { CB_SYS_lseek, TARGET_SYS_lseek },
259 { CB_SYS_unlink, TARGET_SYS_unlink },
260 { CB_SYS_getpid, TARGET_SYS_getpid },
261 { CB_SYS_fstat, TARGET_SYS_fstat64 },
262 { CB_SYS_lstat, TARGET_SYS_lstat64 },
263 { CB_SYS_stat, TARGET_SYS_stat64 },
264 { CB_SYS_pipe, TARGET_SYS_pipe },
265 { CB_SYS_rename, TARGET_SYS_rename },
266 { CB_SYS_truncate, TARGET_SYS_truncate },
267 { CB_SYS_ftruncate, TARGET_SYS_ftruncate },
268 { 0, -1 }
269 };
270
271 /* An older, 32-bit-only stat mapping. */
272 static const char stat32_map[] =
273 "st_dev,2:space,2:st_ino,4:st_mode,2:st_nlink,2:st_uid,2"
274 ":st_gid,2:st_rdev,2:space,2:st_size,4:st_blksize,4:st_blocks,4"
275 ":st_atime,4:space,4:st_mtime,4:space,4:st_ctime,4:space,12";
276
277 /* Map for calls using the 32-bit struct stat. Primarily used by the
278 newlib Linux mapping. */
279 static const CB_TARGET_DEFS_MAP syscall_stat32_map[] =
280 {
281 { CB_SYS_fstat, TARGET_SYS_fstat },
282 { CB_SYS_stat, TARGET_SYS_stat },
283 { 0, -1 }
284 };
285
286 /* Giving the true value for the running sim process will lead to
287 non-time-invariant behavior. */
288 #define TARGET_PID 42
289
290 /* Unfortunately, we don't get this from cris.cpu at the moment, and if
291 we did, we'd still don't get a register number with the "16" offset. */
292 #define TARGET_SRP_REGNUM (16+11)
293
294 /* Extracted by applying
295 awk '/^#define/ { printf "#ifdef %s\n { %s, %s },\n#endif\n", $2, $2, $3;}'
296 on .../include/asm/errno.h in a GNU/Linux/CRIS installation and
297 adjusting the synonyms. */
298
299 static const CB_TARGET_DEFS_MAP errno_map[] =
300 {
301 #ifdef EPERM
302 { EPERM, 1 },
303 #endif
304 #ifdef ENOENT
305 { ENOENT, 2 },
306 #endif
307 #ifdef ESRCH
308 { ESRCH, 3 },
309 #endif
310 #ifdef EINTR
311 { EINTR, 4 },
312 #endif
313 #ifdef EIO
314 { EIO, 5 },
315 #endif
316 #ifdef ENXIO
317 { ENXIO, 6 },
318 #endif
319 #ifdef E2BIG
320 { E2BIG, 7 },
321 #endif
322 #ifdef ENOEXEC
323 { ENOEXEC, 8 },
324 #endif
325 #ifdef EBADF
326 { EBADF, 9 },
327 #endif
328 #ifdef ECHILD
329 { ECHILD, 10 },
330 #endif
331 #ifdef EAGAIN
332 { EAGAIN, 11 },
333 #endif
334 #ifdef ENOMEM
335 { ENOMEM, 12 },
336 #endif
337 #ifdef EACCES
338 { EACCES, 13 },
339 #endif
340 #ifdef EFAULT
341 { EFAULT, 14 },
342 #endif
343 #ifdef ENOTBLK
344 { ENOTBLK, 15 },
345 #endif
346 #ifdef EBUSY
347 { EBUSY, 16 },
348 #endif
349 #ifdef EEXIST
350 { EEXIST, 17 },
351 #endif
352 #ifdef EXDEV
353 { EXDEV, 18 },
354 #endif
355 #ifdef ENODEV
356 { ENODEV, 19 },
357 #endif
358 #ifdef ENOTDIR
359 { ENOTDIR, 20 },
360 #endif
361 #ifdef EISDIR
362 { EISDIR, 21 },
363 #endif
364 #ifdef EINVAL
365 { EINVAL, 22 },
366 #endif
367 #ifdef ENFILE
368 { ENFILE, 23 },
369 #endif
370 #ifdef EMFILE
371 { EMFILE, 24 },
372 #endif
373 #ifdef ENOTTY
374 { ENOTTY, 25 },
375 #endif
376 #ifdef ETXTBSY
377 { ETXTBSY, 26 },
378 #endif
379 #ifdef EFBIG
380 { EFBIG, 27 },
381 #endif
382 #ifdef ENOSPC
383 { ENOSPC, 28 },
384 #endif
385 #ifdef ESPIPE
386 { ESPIPE, 29 },
387 #endif
388 #ifdef EROFS
389 { EROFS, 30 },
390 #endif
391 #ifdef EMLINK
392 { EMLINK, 31 },
393 #endif
394 #ifdef EPIPE
395 { EPIPE, 32 },
396 #endif
397 #ifdef EDOM
398 { EDOM, 33 },
399 #endif
400 #ifdef ERANGE
401 { ERANGE, 34 },
402 #endif
403 #ifdef EDEADLK
404 { EDEADLK, 35 },
405 #endif
406 #ifdef ENAMETOOLONG
407 { ENAMETOOLONG, 36 },
408 #endif
409 #ifdef ENOLCK
410 { ENOLCK, 37 },
411 #endif
412 #ifdef ENOSYS
413 { ENOSYS, 38 },
414 #endif
415 #ifdef ENOTEMPTY
416 { ENOTEMPTY, 39 },
417 #endif
418 #ifdef ELOOP
419 { ELOOP, 40 },
420 #endif
421 #ifdef EWOULDBLOCK
422 { EWOULDBLOCK, 11 },
423 #endif
424 #ifdef ENOMSG
425 { ENOMSG, 42 },
426 #endif
427 #ifdef EIDRM
428 { EIDRM, 43 },
429 #endif
430 #ifdef ECHRNG
431 { ECHRNG, 44 },
432 #endif
433 #ifdef EL2NSYNC
434 { EL2NSYNC, 45 },
435 #endif
436 #ifdef EL3HLT
437 { EL3HLT, 46 },
438 #endif
439 #ifdef EL3RST
440 { EL3RST, 47 },
441 #endif
442 #ifdef ELNRNG
443 { ELNRNG, 48 },
444 #endif
445 #ifdef EUNATCH
446 { EUNATCH, 49 },
447 #endif
448 #ifdef ENOCSI
449 { ENOCSI, 50 },
450 #endif
451 #ifdef EL2HLT
452 { EL2HLT, 51 },
453 #endif
454 #ifdef EBADE
455 { EBADE, 52 },
456 #endif
457 #ifdef EBADR
458 { EBADR, 53 },
459 #endif
460 #ifdef EXFULL
461 { EXFULL, 54 },
462 #endif
463 #ifdef ENOANO
464 { ENOANO, 55 },
465 #endif
466 #ifdef EBADRQC
467 { EBADRQC, 56 },
468 #endif
469 #ifdef EBADSLT
470 { EBADSLT, 57 },
471 #endif
472 #ifdef EDEADLOCK
473 { EDEADLOCK, 35 },
474 #endif
475 #ifdef EBFONT
476 { EBFONT, 59 },
477 #endif
478 #ifdef ENOSTR
479 { ENOSTR, 60 },
480 #endif
481 #ifdef ENODATA
482 { ENODATA, 61 },
483 #endif
484 #ifdef ETIME
485 { ETIME, 62 },
486 #endif
487 #ifdef ENOSR
488 { ENOSR, 63 },
489 #endif
490 #ifdef ENONET
491 { ENONET, 64 },
492 #endif
493 #ifdef ENOPKG
494 { ENOPKG, 65 },
495 #endif
496 #ifdef EREMOTE
497 { EREMOTE, 66 },
498 #endif
499 #ifdef ENOLINK
500 { ENOLINK, 67 },
501 #endif
502 #ifdef EADV
503 { EADV, 68 },
504 #endif
505 #ifdef ESRMNT
506 { ESRMNT, 69 },
507 #endif
508 #ifdef ECOMM
509 { ECOMM, 70 },
510 #endif
511 #ifdef EPROTO
512 { EPROTO, 71 },
513 #endif
514 #ifdef EMULTIHOP
515 { EMULTIHOP, 72 },
516 #endif
517 #ifdef EDOTDOT
518 { EDOTDOT, 73 },
519 #endif
520 #ifdef EBADMSG
521 { EBADMSG, 74 },
522 #endif
523 #ifdef EOVERFLOW
524 { EOVERFLOW, 75 },
525 #endif
526 #ifdef ENOTUNIQ
527 { ENOTUNIQ, 76 },
528 #endif
529 #ifdef EBADFD
530 { EBADFD, 77 },
531 #endif
532 #ifdef EREMCHG
533 { EREMCHG, 78 },
534 #endif
535 #ifdef ELIBACC
536 { ELIBACC, 79 },
537 #endif
538 #ifdef ELIBBAD
539 { ELIBBAD, 80 },
540 #endif
541 #ifdef ELIBSCN
542 { ELIBSCN, 81 },
543 #endif
544 #ifdef ELIBMAX
545 { ELIBMAX, 82 },
546 #endif
547 #ifdef ELIBEXEC
548 { ELIBEXEC, 83 },
549 #endif
550 #ifdef EILSEQ
551 { EILSEQ, 84 },
552 #endif
553 #ifdef ERESTART
554 { ERESTART, 85 },
555 #endif
556 #ifdef ESTRPIPE
557 { ESTRPIPE, 86 },
558 #endif
559 #ifdef EUSERS
560 { EUSERS, 87 },
561 #endif
562 #ifdef ENOTSOCK
563 { ENOTSOCK, 88 },
564 #endif
565 #ifdef EDESTADDRREQ
566 { EDESTADDRREQ, 89 },
567 #endif
568 #ifdef EMSGSIZE
569 { EMSGSIZE, 90 },
570 #endif
571 #ifdef EPROTOTYPE
572 { EPROTOTYPE, 91 },
573 #endif
574 #ifdef ENOPROTOOPT
575 { ENOPROTOOPT, 92 },
576 #endif
577 #ifdef EPROTONOSUPPORT
578 { EPROTONOSUPPORT, 93 },
579 #endif
580 #ifdef ESOCKTNOSUPPORT
581 { ESOCKTNOSUPPORT, 94 },
582 #endif
583 #ifdef EOPNOTSUPP
584 { EOPNOTSUPP, 95 },
585 #endif
586 #ifdef EPFNOSUPPORT
587 { EPFNOSUPPORT, 96 },
588 #endif
589 #ifdef EAFNOSUPPORT
590 { EAFNOSUPPORT, 97 },
591 #endif
592 #ifdef EADDRINUSE
593 { EADDRINUSE, 98 },
594 #endif
595 #ifdef EADDRNOTAVAIL
596 { EADDRNOTAVAIL, 99 },
597 #endif
598 #ifdef ENETDOWN
599 { ENETDOWN, 100 },
600 #endif
601 #ifdef ENETUNREACH
602 { ENETUNREACH, 101 },
603 #endif
604 #ifdef ENETRESET
605 { ENETRESET, 102 },
606 #endif
607 #ifdef ECONNABORTED
608 { ECONNABORTED, 103 },
609 #endif
610 #ifdef ECONNRESET
611 { ECONNRESET, 104 },
612 #endif
613 #ifdef ENOBUFS
614 { ENOBUFS, 105 },
615 #endif
616 #ifdef EISCONN
617 { EISCONN, 106 },
618 #endif
619 #ifdef ENOTCONN
620 { ENOTCONN, 107 },
621 #endif
622 #ifdef ESHUTDOWN
623 { ESHUTDOWN, 108 },
624 #endif
625 #ifdef ETOOMANYREFS
626 { ETOOMANYREFS, 109 },
627 #endif
628 #ifdef ETIMEDOUT
629 { ETIMEDOUT, 110 },
630 #endif
631 #ifdef ECONNREFUSED
632 { ECONNREFUSED, 111 },
633 #endif
634 #ifdef EHOSTDOWN
635 { EHOSTDOWN, 112 },
636 #endif
637 #ifdef EHOSTUNREACH
638 { EHOSTUNREACH, 113 },
639 #endif
640 #ifdef EALREADY
641 { EALREADY, 114 },
642 #endif
643 #ifdef EINPROGRESS
644 { EINPROGRESS, 115 },
645 #endif
646 #ifdef ESTALE
647 { ESTALE, 116 },
648 #endif
649 #ifdef EUCLEAN
650 { EUCLEAN, 117 },
651 #endif
652 #ifdef ENOTNAM
653 { ENOTNAM, 118 },
654 #endif
655 #ifdef ENAVAIL
656 { ENAVAIL, 119 },
657 #endif
658 #ifdef EISNAM
659 { EISNAM, 120 },
660 #endif
661 #ifdef EREMOTEIO
662 { EREMOTEIO, 121 },
663 #endif
664 #ifdef EDQUOT
665 { EDQUOT, 122 },
666 #endif
667 #ifdef ENOMEDIUM
668 { ENOMEDIUM, 123 },
669 #endif
670 #ifdef EMEDIUMTYPE
671 { EMEDIUMTYPE, 124 },
672 #endif
673 { 0, -1 }
674 };
675
676 /* Extracted by applying
677 perl -ne 'if ($_ =~ /^#define/) { split;
678 printf "#ifdef $_[1]\n { %s, 0x%x },\n#endif\n",
679 $_[1], $_[2] =~ /^0/ ? oct($_[2]) : $_[2];}'
680 on pertinent parts of .../include/asm/fcntl.h in a GNU/Linux/CRIS
681 installation and removing synonyms and unnecessary items. Don't
682 forget the end-marker. */
683
684 /* These we treat specially, as they're used in the fcntl F_GETFL
685 syscall. For consistency, open_map is also manually edited to use
686 these macros. */
687 #define TARGET_O_ACCMODE 0x3
688 #define TARGET_O_RDONLY 0x0
689 #define TARGET_O_WRONLY 0x1
690
691 static const CB_TARGET_DEFS_MAP open_map[] = {
692 #ifdef O_ACCMODE
693 { O_ACCMODE, TARGET_O_ACCMODE },
694 #endif
695 #ifdef O_RDONLY
696 { O_RDONLY, TARGET_O_RDONLY },
697 #endif
698 #ifdef O_WRONLY
699 { O_WRONLY, TARGET_O_WRONLY },
700 #endif
701 #ifdef O_RDWR
702 { O_RDWR, 0x2 },
703 #endif
704 #ifdef O_CREAT
705 { O_CREAT, 0x40 },
706 #endif
707 #ifdef O_EXCL
708 { O_EXCL, 0x80 },
709 #endif
710 #ifdef O_NOCTTY
711 { O_NOCTTY, 0x100 },
712 #endif
713 #ifdef O_TRUNC
714 { O_TRUNC, 0x200 },
715 #endif
716 #ifdef O_APPEND
717 { O_APPEND, 0x400 },
718 #endif
719 #ifdef O_NONBLOCK
720 { O_NONBLOCK, 0x800 },
721 #endif
722 #ifdef O_NDELAY
723 { O_NDELAY, 0x0 },
724 #endif
725 #ifdef O_SYNC
726 { O_SYNC, 0x1000 },
727 #endif
728 #ifdef FASYNC
729 { FASYNC, 0x2000 },
730 #endif
731 #ifdef O_DIRECT
732 { O_DIRECT, 0x4000 },
733 #endif
734 #ifdef O_LARGEFILE
735 { O_LARGEFILE, 0x8000 },
736 #endif
737 #ifdef O_DIRECTORY
738 { O_DIRECTORY, 0x10000 },
739 #endif
740 #ifdef O_NOFOLLOW
741 { O_NOFOLLOW, 0x20000 },
742 #endif
743 { -1, -1 }
744 };
745
746 /* Needed for the cris_pipe_nonempty and cris_pipe_empty syscalls. */
747 static SIM_CPU *current_cpu_for_cb_callback;
748
749 static int syscall_read_mem (host_callback *, struct cb_syscall *,
750 unsigned long, char *, int);
751 static int syscall_write_mem (host_callback *, struct cb_syscall *,
752 unsigned long, const char *, int);
753 static USI create_map (SIM_DESC, struct cris_sim_mmapped_page **,
754 USI addr, USI len);
755 static USI unmap_pages (SIM_DESC, struct cris_sim_mmapped_page **,
756 USI addr, USI len);
757 static USI is_mapped (SIM_DESC, struct cris_sim_mmapped_page **,
758 USI addr, USI len);
759 static void dump_statistics (SIM_CPU *current_cpu);
760 static void make_first_thread (SIM_CPU *current_cpu);
761
762 /* Read/write functions for system call interface. */
763
764 static int
765 syscall_read_mem (host_callback *cb ATTRIBUTE_UNUSED,
766 struct cb_syscall *sc,
767 unsigned long taddr, char *buf, int bytes)
768 {
769 SIM_DESC sd = (SIM_DESC) sc->p1;
770 SIM_CPU *cpu = (SIM_CPU *) sc->p2;
771
772 return sim_core_read_buffer (sd, cpu, read_map, buf, taddr, bytes);
773 }
774
775 static int
776 syscall_write_mem (host_callback *cb ATTRIBUTE_UNUSED,
777 struct cb_syscall *sc,
778 unsigned long taddr, const char *buf, int bytes)
779 {
780 SIM_DESC sd = (SIM_DESC) sc->p1;
781 SIM_CPU *cpu = (SIM_CPU *) sc->p2;
782
783 return sim_core_write_buffer (sd, cpu, write_map, buf, taddr, bytes);
784 }
785
786 /* When we risk running self-modified code (as in trampolines), this is
787 called from special-case insns. The silicon CRIS CPU:s have enough
788 cache snooping implemented making this a simulator-only issue. Tests:
789 gcc.c-torture/execute/931002-1.c execution, -O3 -g
790 gcc.c-torture/execute/931002-1.c execution, -O3 -fomit-frame-pointer. */
791
792 void
793 cris_flush_simulator_decode_cache (SIM_CPU *current_cpu,
794 USI pc ATTRIBUTE_UNUSED)
795 {
796 SIM_DESC sd = CPU_STATE (current_cpu);
797
798 #if WITH_SCACHE
799 if (USING_SCACHE_P (sd))
800 scache_flush_cpu (current_cpu);
801 #endif
802 }
803
804 /* Output statistics at the end of a run. */
805 static void
806 dump_statistics (SIM_CPU *current_cpu)
807 {
808 SIM_DESC sd = CPU_STATE (current_cpu);
809 CRIS_MISC_PROFILE *profp
810 = CPU_CRIS_MISC_PROFILE (current_cpu);
811 unsigned64 total = profp->basic_cycle_count;
812 const char *textmsg = "Basic clock cycles, total @: %llu\n";
813
814 /* The --cris-stats={basic|unaligned|schedulable|all} counts affect
815 what's included in the "total" count only. */
816 switch (CPU_CRIS_MISC_PROFILE (current_cpu)->flags
817 & FLAG_CRIS_MISC_PROFILE_ALL)
818 {
819 case FLAG_CRIS_MISC_PROFILE_SIMPLE:
820 break;
821
822 case (FLAG_CRIS_MISC_PROFILE_UNALIGNED | FLAG_CRIS_MISC_PROFILE_SIMPLE):
823 textmsg
824 = "Clock cycles including stall cycles for unaligned accesses @: %llu\n";
825 total += profp->unaligned_mem_dword_count;
826 break;
827
828 case (FLAG_CRIS_MISC_PROFILE_SCHEDULABLE | FLAG_CRIS_MISC_PROFILE_SIMPLE):
829 textmsg = "Schedulable clock cycles, total @: %llu\n";
830 total
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 break;
839
840 case FLAG_CRIS_MISC_PROFILE_ALL:
841 textmsg = "All accounted clock cycles, total @: %llu\n";
842 total
843 += (profp->memsrc_stall_count
844 + profp->memraw_stall_count
845 + profp->movemsrc_stall_count
846 + profp->movemdst_stall_count
847 + profp->movemaddr_stall_count
848 + profp->mulsrc_stall_count
849 + profp->jumpsrc_stall_count
850 + profp->branch_stall_count
851 + profp->jumptarget_stall_count
852 + profp->unaligned_mem_dword_count);
853 break;
854
855 default:
856 abort ();
857
858 sim_io_eprintf (sd,
859 "Internal inconsistency at %s:%d",
860 __FILE__, __LINE__);
861 sim_engine_halt (sd, current_cpu, NULL, 0,
862 sim_stopped, SIM_SIGILL);
863 }
864
865 /* Historically, these messages have gone to stderr, so we'll keep it
866 that way. It's also easier to then tell it from normal program
867 output. FIXME: Add redirect option like "run -e file". */
868 sim_io_eprintf (sd, textmsg, total);
869
870 /* For v32, unaligned_mem_dword_count should always be 0. For
871 v10, memsrc_stall_count should always be 0. */
872 sim_io_eprintf (sd, "Memory source stall cycles: %llu\n",
873 (unsigned long long) (profp->memsrc_stall_count
874 + profp->unaligned_mem_dword_count));
875 sim_io_eprintf (sd, "Memory read-after-write stall cycles: %llu\n",
876 (unsigned long long) profp->memraw_stall_count);
877 sim_io_eprintf (sd, "Movem source stall cycles: %llu\n",
878 (unsigned long long) profp->movemsrc_stall_count);
879 sim_io_eprintf (sd, "Movem destination stall cycles: %llu\n",
880 (unsigned long long) profp->movemdst_stall_count);
881 sim_io_eprintf (sd, "Movem address stall cycles: %llu\n",
882 (unsigned long long) profp->movemaddr_stall_count);
883 sim_io_eprintf (sd, "Multiplication source stall cycles: %llu\n",
884 (unsigned long long) profp->mulsrc_stall_count);
885 sim_io_eprintf (sd, "Jump source stall cycles: %llu\n",
886 (unsigned long long) profp->jumpsrc_stall_count);
887 sim_io_eprintf (sd, "Branch misprediction stall cycles: %llu\n",
888 (unsigned long long) profp->branch_stall_count);
889 sim_io_eprintf (sd, "Jump target stall cycles: %llu\n",
890 (unsigned long long) profp->jumptarget_stall_count);
891 }
892
893 /* Check whether any part of [addr .. addr + len - 1] is already mapped.
894 Return 1 if a overlap detected, 0 otherwise. */
895
896 static USI
897 is_mapped (SIM_DESC sd ATTRIBUTE_UNUSED,
898 struct cris_sim_mmapped_page **rootp,
899 USI addr, USI len)
900 {
901 struct cris_sim_mmapped_page *mapp;
902
903 if (len == 0 || (len & 8191))
904 abort ();
905
906 /* Iterate over the reverse-address sorted pages until we find a page in
907 or lower than the checked area. */
908 for (mapp = *rootp; mapp != NULL && mapp->addr >= addr; mapp = mapp->prev)
909 if (mapp->addr < addr + len && mapp->addr >= addr)
910 return 1;
911
912 return 0;
913 }
914
915 /* Create mmapped memory. */
916
917 static USI
918 create_map (SIM_DESC sd, struct cris_sim_mmapped_page **rootp, USI addr,
919 USI len)
920 {
921 struct cris_sim_mmapped_page *mapp;
922 struct cris_sim_mmapped_page **higher_prevp = rootp;
923 USI new_addr = 0x40000000;
924
925 if (addr != 0)
926 new_addr = addr;
927 else if (*rootp)
928 new_addr = rootp[0]->addr + 8192;
929
930 if (len != 8192)
931 {
932 USI page_addr;
933
934 if (len & 8191)
935 /* Which is better: return an error for this, or just round it up? */
936 abort ();
937
938 /* Do a recursive call for each page in the request. */
939 for (page_addr = new_addr; len != 0; page_addr += 8192, len -= 8192)
940 if (create_map (sd, rootp, page_addr, 8192) >= (USI) -8191)
941 abort ();
942
943 return new_addr;
944 }
945
946 for (mapp = *rootp;
947 mapp != NULL && mapp->addr > new_addr;
948 mapp = mapp->prev)
949 higher_prevp = &mapp->prev;
950
951 /* Allocate the new page, on the next higher page from the last one
952 allocated, and link in the new descriptor before previous ones. */
953 mapp = malloc (sizeof (*mapp));
954
955 if (mapp == NULL)
956 return (USI) -ENOMEM;
957
958 sim_core_attach (sd, NULL, 0, access_read_write_exec, 0,
959 new_addr, len,
960 0, NULL, NULL);
961
962 mapp->addr = new_addr;
963 mapp->prev = *higher_prevp;
964 *higher_prevp = mapp;
965
966 return new_addr;
967 }
968
969 /* Unmap one or more pages. */
970
971 static USI
972 unmap_pages (SIM_DESC sd, struct cris_sim_mmapped_page **rootp, USI addr,
973 USI len)
974 {
975 struct cris_sim_mmapped_page *mapp;
976 struct cris_sim_mmapped_page **higher_prevp = rootp;
977
978 if (len != 8192)
979 {
980 USI page_addr;
981
982 if (len & 8191)
983 /* Which is better: return an error for this, or just round it up? */
984 abort ();
985
986 /* Loop backwards to make each call is O(1) over the number of pages
987 allocated, if we're unmapping from the high end of the pages. */
988 for (page_addr = addr + len - 8192;
989 page_addr >= addr;
990 page_addr -= 8192)
991 if (unmap_pages (sd, rootp, page_addr, 8192) != 0)
992 abort ();
993
994 return 0;
995 }
996
997 for (mapp = *rootp; mapp != NULL && mapp->addr > addr; mapp = mapp->prev)
998 higher_prevp = &mapp->prev;
999
1000 if (mapp == NULL || mapp->addr != addr)
1001 return EINVAL;
1002
1003 *higher_prevp = mapp->prev;
1004 sim_core_detach (sd, NULL, 0, 0, addr);
1005 free (mapp);
1006 return 0;
1007 }
1008
1009 /* The semantic code invokes this for illegal (unrecognized) instructions. */
1010
1011 SEM_PC
1012 sim_engine_invalid_insn (SIM_CPU *current_cpu, IADDR cia, SEM_PC vpc)
1013 {
1014 SIM_DESC sd = CPU_STATE (current_cpu);
1015
1016 sim_engine_halt (sd, current_cpu, NULL, cia, sim_stopped, SIM_SIGILL);
1017 return vpc;
1018 }
1019
1020 /* Handlers from the CGEN description that should not be called. */
1021
1022 USI
1023 cris_bmod_handler (SIM_CPU *current_cpu ATTRIBUTE_UNUSED,
1024 UINT srcreg ATTRIBUTE_UNUSED,
1025 USI dstreg ATTRIBUTE_UNUSED)
1026 {
1027 abort ();
1028 }
1029
1030 void
1031 h_supr_set_handler (SIM_CPU *current_cpu ATTRIBUTE_UNUSED,
1032 UINT index ATTRIBUTE_UNUSED,
1033 USI page ATTRIBUTE_UNUSED,
1034 USI newval ATTRIBUTE_UNUSED)
1035 {
1036 abort ();
1037 }
1038
1039 USI
1040 h_supr_get_handler (SIM_CPU *current_cpu ATTRIBUTE_UNUSED,
1041 UINT index ATTRIBUTE_UNUSED,
1042 USI page ATTRIBUTE_UNUSED)
1043 {
1044 abort ();
1045 }
1046
1047 /* Swap one context for another. */
1048
1049 static void
1050 schedule (SIM_CPU *current_cpu, int next)
1051 {
1052 /* Need to mark context-switches in the trace output. */
1053 if ((CPU_CRIS_MISC_PROFILE (current_cpu)->flags
1054 & FLAG_CRIS_MISC_PROFILE_XSIM_TRACE))
1055 cris_trace_printf (CPU_STATE (current_cpu), current_cpu,
1056 "\t#:%d\n", next);
1057
1058 /* Copy the current context (if there is one) to its slot. */
1059 if (current_cpu->thread_data[current_cpu->threadno].cpu_context)
1060 memcpy (current_cpu->thread_data[current_cpu->threadno].cpu_context,
1061 &current_cpu->cpu_data_placeholder,
1062 current_cpu->thread_cpu_data_size);
1063
1064 /* Copy the new context from its slot. */
1065 memcpy (&current_cpu->cpu_data_placeholder,
1066 current_cpu->thread_data[next].cpu_context,
1067 current_cpu->thread_cpu_data_size);
1068
1069 /* Update needed stuff to indicate the new context. */
1070 current_cpu->threadno = next;
1071
1072 /* Handle pending signals. */
1073 if (current_cpu->thread_data[next].sigpending
1074 /* We don't run nested signal handlers. This means that pause(2)
1075 and sigsuspend(2) do not work in sighandlers, but that
1076 shouldn't be too hard a restriction. It also greatly
1077 simplifies the code. */
1078 && current_cpu->thread_data[next].cpu_context_atsignal == NULL)
1079 {
1080 int sig;
1081
1082 /* See if there's really a pending, non-blocked handler. We don't
1083 queue signals, so just use the first one in ascending order. */
1084 for (sig = 0; sig < 64; sig++)
1085 if (current_cpu->thread_data[next].sigdata[sig].pending
1086 && !current_cpu->thread_data[next].sigdata[sig].blocked)
1087 {
1088 bfd_byte regbuf[4];
1089 USI sp;
1090 int i;
1091 USI blocked;
1092 USI pc = sim_pc_get (current_cpu);
1093
1094 /* It's simpler to save the CPU context inside the simulator
1095 than on the stack. */
1096 current_cpu->thread_data[next].cpu_context_atsignal
1097 = (*current_cpu
1098 ->make_thread_cpu_data) (current_cpu,
1099 current_cpu->thread_data[next]
1100 .cpu_context);
1101
1102 (*CPU_REG_FETCH (current_cpu)) (current_cpu, H_GR_SP, regbuf, 4);
1103 sp = bfd_getl32 (regbuf);
1104
1105 /* Make sure we have an aligned stack. */
1106 sp &= ~3;
1107
1108 /* Make room for the signal frame, aligned. FIXME: Check that
1109 the memory exists, map it in if absent. (BTW, should also
1110 implement on-access automatic stack allocation). */
1111 sp -= 20;
1112
1113 /* This isn't the same signal frame as the kernel uses, because
1114 we don't want to bother getting all registers on and off the
1115 stack. */
1116
1117 /* First, we store the currently blocked signals. */
1118 blocked = 0;
1119 for (i = 0; i < 32; i++)
1120 blocked
1121 |= current_cpu->thread_data[next].sigdata[i + 1].blocked << i;
1122 sim_core_write_aligned_4 (current_cpu, pc, 0, sp, blocked);
1123 blocked = 0;
1124 for (i = 0; i < 31; i++)
1125 blocked
1126 |= current_cpu->thread_data[next].sigdata[i + 33].blocked << i;
1127 sim_core_write_aligned_4 (current_cpu, pc, 0, sp + 4, blocked);
1128
1129 /* Then, the actual instructions. This is CPU-specific, but we
1130 use instructions from the common subset for v10 and v32 which
1131 should be safe for the time being but could be parametrized
1132 if need be. */
1133 /* MOVU.W [PC+],R9. */
1134 sim_core_write_aligned_2 (current_cpu, pc, 0, sp + 8, 0x9c5f);
1135 /* .WORD TARGET_SYS_sigreturn. */
1136 sim_core_write_aligned_2 (current_cpu, pc, 0, sp + 10,
1137 TARGET_SYS_sigreturn);
1138 /* BREAK 13. */
1139 sim_core_write_aligned_2 (current_cpu, pc, 0, sp + 12, 0xe93d);
1140
1141 /* NOP (on v32; it's SETF on v10, but is the correct compatible
1142 instruction. Still, it doesn't matter because v10 has no
1143 delay slot for BREAK so it will not be executed). */
1144 sim_core_write_aligned_2 (current_cpu, pc, 0, sp + 16, 0x05b0);
1145
1146 /* Modify registers to hold the right values for the sighandler
1147 context: updated stackpointer and return address pointing to
1148 the sigreturn stub. */
1149 bfd_putl32 (sp, regbuf);
1150 (*CPU_REG_STORE (current_cpu)) (current_cpu, H_GR_SP, regbuf, 4);
1151 bfd_putl32 (sp + 8, regbuf);
1152 (*CPU_REG_STORE (current_cpu)) (current_cpu, TARGET_SRP_REGNUM,
1153 regbuf, 4);
1154
1155 current_cpu->thread_data[next].sigdata[sig].pending = 0;
1156
1157 /* Block this signal (for the duration of the sighandler). */
1158 current_cpu->thread_data[next].sigdata[sig].blocked = 1;
1159
1160 sim_pc_set (current_cpu, current_cpu->sighandler[sig]);
1161 bfd_putl32 (sig, regbuf);
1162 (*CPU_REG_STORE (current_cpu)) (current_cpu, H_GR_R10,
1163 regbuf, 4);
1164
1165 /* We ignore a SA_SIGINFO flag in the sigaction call; the code I
1166 needed all this for, specifies a SA_SIGINFO call but treats it
1167 like an ordinary sighandler; only the signal number argument is
1168 inspected. To make future need to implement SA_SIGINFO
1169 correctly possible, we set the siginfo argument register to a
1170 magic (hopefully non-address) number. (NB: then, you should
1171 just need to pass the siginfo argument; it seems you probably
1172 don't need to implement the specific rt_sigreturn.) */
1173 bfd_putl32 (0xbad5161f, regbuf);
1174 (*CPU_REG_STORE (current_cpu)) (current_cpu, H_GR_R11,
1175 regbuf, 4);
1176
1177 /* The third argument is unused and the kernel sets it to 0. */
1178 bfd_putl32 (0, regbuf);
1179 (*CPU_REG_STORE (current_cpu)) (current_cpu, H_GR_R12,
1180 regbuf, 4);
1181 return;
1182 }
1183
1184 /* No, there actually was no pending signal for this thread. Reset
1185 this flag. */
1186 current_cpu->thread_data[next].sigpending = 0;
1187 }
1188 }
1189
1190 /* Reschedule the simplest possible way until something else is absolutely
1191 necessary:
1192 - A. Find the next process (round-robin) that doesn't have at_syscall
1193 set, schedule it.
1194 - B. If there is none, just run the next process, round-robin.
1195 - Clear at_syscall for the current process. */
1196
1197 static void
1198 reschedule (SIM_CPU *current_cpu)
1199 {
1200 int i;
1201
1202 /* Iterate over all thread slots, because after a few thread creations
1203 and exits, we don't know where the live ones are. */
1204 for (i = (current_cpu->threadno + 1) % SIM_TARGET_MAX_THREADS;
1205 i != current_cpu->threadno;
1206 i = (i + 1) % SIM_TARGET_MAX_THREADS)
1207 if (current_cpu->thread_data[i].cpu_context
1208 && current_cpu->thread_data[i].at_syscall == 0)
1209 {
1210 schedule (current_cpu, i);
1211 return;
1212 }
1213
1214 /* Pick any next live thread. */
1215 for (i = (current_cpu->threadno + 1) % SIM_TARGET_MAX_THREADS;
1216 i != current_cpu->threadno;
1217 i = (i + 1) % SIM_TARGET_MAX_THREADS)
1218 if (current_cpu->thread_data[i].cpu_context)
1219 {
1220 schedule (current_cpu, i);
1221 return;
1222 }
1223
1224 /* More than one live thread, but we couldn't find the next one? */
1225 abort ();
1226 }
1227
1228 /* Set up everything to receive (or IGN) an incoming signal to the
1229 current context. */
1230
1231 static int
1232 deliver_signal (SIM_CPU *current_cpu, int sig, unsigned int pid)
1233 {
1234 int i;
1235 USI pc = sim_pc_get (current_cpu);
1236
1237 /* Find the thread index of the pid. */
1238 for (i = 0; i < SIM_TARGET_MAX_THREADS; i++)
1239 /* Apparently it's ok to send signals to zombies (so a check for
1240 current_cpu->thread_data[i].cpu_context != NULL would be
1241 wrong). */
1242 if (current_cpu->thread_data[i].threadid == pid - TARGET_PID)
1243 {
1244 if (sig < 64)
1245 switch (current_cpu->sighandler[sig])
1246 {
1247 case TARGET_SIG_DFL:
1248 switch (sig)
1249 {
1250 /* The following according to the glibc
1251 documentation. (The kernel code has non-obvious
1252 execution paths.) */
1253 case TARGET_SIGFPE:
1254 case TARGET_SIGILL:
1255 case TARGET_SIGSEGV:
1256 case TARGET_SIGBUS:
1257 case TARGET_SIGABRT:
1258 case TARGET_SIGTRAP:
1259 case TARGET_SIGSYS:
1260
1261 case TARGET_SIGTERM:
1262 case TARGET_SIGINT:
1263 case TARGET_SIGQUIT:
1264 case TARGET_SIGKILL:
1265 case TARGET_SIGHUP:
1266
1267 case TARGET_SIGALRM:
1268 case TARGET_SIGVTALRM:
1269 case TARGET_SIGPROF:
1270 case TARGET_SIGSTOP:
1271
1272 case TARGET_SIGPIPE:
1273 case TARGET_SIGLOST:
1274 case TARGET_SIGXCPU:
1275 case TARGET_SIGXFSZ:
1276 case TARGET_SIGUSR1:
1277 case TARGET_SIGUSR2:
1278 sim_io_eprintf (CPU_STATE (current_cpu),
1279 "Exiting pid %d due to signal %d\n",
1280 pid, sig);
1281 sim_engine_halt (CPU_STATE (current_cpu), current_cpu,
1282 NULL, pc, sim_stopped,
1283 sig == TARGET_SIGABRT
1284 ? SIM_SIGABRT : SIM_SIGILL);
1285 return 0;
1286
1287 /* The default for all other signals is to be ignored. */
1288 default:
1289 return 0;
1290 }
1291
1292 case TARGET_SIG_IGN:
1293 switch (sig)
1294 {
1295 case TARGET_SIGKILL:
1296 case TARGET_SIGSTOP:
1297 /* Can't ignore these signals. */
1298 sim_io_eprintf (CPU_STATE (current_cpu),
1299 "Exiting pid %d due to signal %d\n",
1300 pid, sig);
1301 sim_engine_halt (CPU_STATE (current_cpu), current_cpu,
1302 NULL, pc, sim_stopped, SIM_SIGILL);
1303 return 0;
1304
1305 default:
1306 return 0;
1307 }
1308 break;
1309
1310 default:
1311 /* Mark the signal as pending, making schedule () check
1312 closer. The signal will be handled when the thread is
1313 scheduled and the signal is unblocked. */
1314 current_cpu->thread_data[i].sigdata[sig].pending = 1;
1315 current_cpu->thread_data[i].sigpending = 1;
1316 return 0;
1317 }
1318 else
1319 {
1320 sim_io_eprintf (CPU_STATE (current_cpu),
1321 "Unimplemented signal: %d\n", sig);
1322 sim_engine_halt (CPU_STATE (current_cpu), current_cpu, NULL, pc,
1323 sim_stopped, SIM_SIGILL);
1324 }
1325 }
1326
1327 return
1328 -cb_host_to_target_errno (STATE_CALLBACK (CPU_STATE (current_cpu)),
1329 ESRCH);
1330 }
1331
1332 /* Make the vector and the first item, the main thread. */
1333
1334 static void
1335 make_first_thread (SIM_CPU *current_cpu)
1336 {
1337 current_cpu->thread_data
1338 = xcalloc (1,
1339 SIM_TARGET_MAX_THREADS
1340 * sizeof (current_cpu->thread_data[0]));
1341 current_cpu->thread_data[0].cpu_context
1342 = (*current_cpu->make_thread_cpu_data) (current_cpu,
1343 &current_cpu
1344 ->cpu_data_placeholder);
1345 current_cpu->thread_data[0].parent_threadid = -1;
1346
1347 /* For good measure. */
1348 if (TARGET_SIG_DFL != 0)
1349 abort ();
1350 }
1351
1352 /* Handle unknown system calls. Returns (if it does) the syscall
1353 return value. */
1354
1355 static USI
1356 cris_unknown_syscall (SIM_CPU *current_cpu, USI pc, char *s, ...)
1357 {
1358 SIM_DESC sd = CPU_STATE (current_cpu);
1359 host_callback *cb = STATE_CALLBACK (sd);
1360
1361 if (cris_unknown_syscall_action == CRIS_USYSC_MSG_STOP
1362 || cris_unknown_syscall_action == CRIS_USYSC_MSG_ENOSYS)
1363 {
1364 va_list ap;
1365
1366 va_start (ap, s);
1367 sim_io_evprintf (sd, s, ap);
1368 va_end (ap);
1369
1370 if (cris_unknown_syscall_action == CRIS_USYSC_MSG_STOP)
1371 sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped, SIM_SIGILL);
1372 }
1373
1374 return -cb_host_to_target_errno (cb, ENOSYS);
1375 }
1376
1377 /* Main function: the handler of the "break 13" syscall insn. */
1378
1379 USI
1380 cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
1381 USI arg2, USI arg3, USI arg4, USI arg5, USI arg6,
1382 USI pc)
1383 {
1384 CB_SYSCALL s;
1385 SIM_DESC sd = CPU_STATE (current_cpu);
1386 host_callback *cb = STATE_CALLBACK (sd);
1387 int retval;
1388 int threadno = current_cpu->threadno;
1389
1390 current_cpu->syscalls++;
1391
1392 CB_SYSCALL_INIT (&s);
1393 s.func = callnum;
1394 s.arg1 = arg1;
1395 s.arg2 = arg2;
1396 s.arg3 = arg3;
1397
1398 if (callnum == TARGET_SYS_exit && current_cpu->m1threads == 0)
1399 {
1400 if (CPU_CRIS_MISC_PROFILE (current_cpu)->flags
1401 & FLAG_CRIS_MISC_PROFILE_ALL)
1402 dump_statistics (current_cpu);
1403 sim_engine_halt (sd, current_cpu, NULL, pc, sim_exited, arg1);
1404 }
1405
1406 s.p1 = (PTR) sd;
1407 s.p2 = (PTR) current_cpu;
1408 s.read_mem = syscall_read_mem;
1409 s.write_mem = syscall_write_mem;
1410
1411 current_cpu_for_cb_callback = current_cpu;
1412
1413 if (cb_syscall (cb, &s) != CB_RC_OK)
1414 {
1415 abort ();
1416 sim_io_eprintf (sd, "Break 13: invalid %d? Returned %ld\n", callnum,
1417 s.result);
1418 sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped, SIM_SIGILL);
1419 }
1420
1421 retval = s.result == -1 ? -s.errcode : s.result;
1422
1423 if (s.errcode != 0 && s.errcode == cb_host_to_target_errno (cb, ENOSYS))
1424 {
1425 /* If the generic simulator call said ENOSYS, then let's try the
1426 ones we know ourselves.
1427
1428 The convention is to provide *very limited* functionality on an
1429 as-needed basis, only what's covered by the test-suite, tests
1430 added when functionality changes and abort with a descriptive
1431 message for *everything* else. Where there's no test-case, we
1432 just abort. */
1433 switch (callnum)
1434 {
1435 case 0:
1436 /* It's a pretty safe bet that the "old setup() system call"
1437 number will not be re-used; we can't say the same for higher
1438 numbers. We treat this simulator-generated call as "wait
1439 forever"; we re-run this insn. The wait is ended by a
1440 callback. Sanity check that this is the reason we got
1441 here. */
1442 if (current_cpu->thread_data == NULL
1443 || (current_cpu->thread_data[threadno].pipe_write_fd == 0))
1444 goto unimplemented_syscall;
1445
1446 sim_pc_set (current_cpu, pc);
1447 retval = arg1;
1448 break;
1449
1450 case TARGET_SYS_fcntl64:
1451 case TARGET_SYS_fcntl:
1452 switch (arg2)
1453 {
1454 case 1:
1455 /* F_GETFD.
1456 Glibc checks stdin, stdout and stderr fd:s for
1457 close-on-exec security sanity. We just need to provide a
1458 OK return value. If we really need to have a
1459 close-on-exec flag true, we could just do a real fcntl
1460 here. */
1461 retval = 0;
1462 break;
1463
1464 case 2:
1465 /* F_SETFD. Just ignore attempts to set the close-on-exec
1466 flag. */
1467 retval = 0;
1468 break;
1469
1470 case 3:
1471 /* F_GETFL. Check for the special case for open+fdopen. */
1472 if (current_cpu->last_syscall == TARGET_SYS_open
1473 && arg1 == current_cpu->last_open_fd)
1474 {
1475 retval = current_cpu->last_open_flags & TARGET_O_ACCMODE;
1476 break;
1477 }
1478 else if (arg1 == 0)
1479 {
1480 /* Because we can't freopen fd:s 0, 1, 2 to mean
1481 something else than stdin, stdout and stderr
1482 (sim/common/syscall.c:cb_syscall special cases fd
1483 0, 1 and 2), we know what flags that we can
1484 sanely return for these fd:s. */
1485 retval = TARGET_O_RDONLY;
1486 break;
1487 }
1488 else if (arg1 == 1 || arg1 == 2)
1489 {
1490 retval = TARGET_O_WRONLY;
1491 break;
1492 }
1493 /* FALLTHROUGH */
1494 default:
1495 /* Nothing else is implemented. */
1496 retval
1497 = cris_unknown_syscall (current_cpu, pc,
1498 "Unimplemented %s syscall "
1499 "(fd: 0x%lx: cmd: 0x%lx arg: "
1500 "0x%lx)\n",
1501 callnum == TARGET_SYS_fcntl
1502 ? "fcntl" : "fcntl64",
1503 (unsigned long) (USI) arg1,
1504 (unsigned long) (USI) arg2,
1505 (unsigned long) (USI) arg3);
1506 break;
1507 }
1508 break;
1509
1510 case TARGET_SYS_uname:
1511 {
1512 /* Fill in a few constants to appease glibc. */
1513 static const char sim_utsname[6][65] =
1514 {
1515 "Linux",
1516 "sim-target",
1517 "2.4.5",
1518 TARGET_UTSNAME,
1519 "cris",
1520 "localdomain"
1521 };
1522
1523 if ((s.write_mem) (cb, &s, arg1, (const char *) sim_utsname,
1524 sizeof (sim_utsname))
1525 != sizeof (sim_utsname))
1526 retval = -cb_host_to_target_errno (cb, EFAULT);
1527 else
1528 retval = 0;
1529 break;
1530 }
1531
1532 case TARGET_SYS_geteuid32:
1533 /* We tell the truth with these. Maybe we shouldn't, but it
1534 should match the "stat" information. */
1535 retval = geteuid ();
1536 break;
1537
1538 case TARGET_SYS_getuid32:
1539 retval = getuid ();
1540 break;
1541
1542 case TARGET_SYS_getegid32:
1543 retval = getegid ();
1544 break;
1545
1546 case TARGET_SYS_getgid32:
1547 retval = getgid ();
1548 break;
1549
1550 case TARGET_SYS_brk:
1551 /* Most often, we just return the argument, like the Linux
1552 kernel. */
1553 retval = arg1;
1554
1555 if (arg1 == 0)
1556 retval = current_cpu->endbrk;
1557 else if (arg1 <= current_cpu->endmem)
1558 current_cpu->endbrk = arg1;
1559 else
1560 {
1561 USI new_end = (arg1 + 8191) & ~8191;
1562
1563 /* If the simulator wants to brk more than a certain very
1564 large amount, something is wrong. FIXME: Return an error
1565 or abort? Have command-line selectable? */
1566 if (new_end - current_cpu->endmem > SIM_MAX_ALLOC_CHUNK)
1567 {
1568 current_cpu->endbrk = current_cpu->endmem;
1569 retval = current_cpu->endmem;
1570 break;
1571 }
1572
1573 sim_core_attach (sd, NULL, 0, access_read_write_exec, 0,
1574 current_cpu->endmem,
1575 new_end - current_cpu->endmem,
1576 0, NULL, NULL);
1577 current_cpu->endbrk = arg1;
1578 current_cpu->endmem = new_end;
1579 }
1580 break;
1581
1582 case TARGET_SYS_getpid:
1583 /* Correct until CLONE_THREAD is implemented. */
1584 retval = current_cpu->thread_data == NULL
1585 ? TARGET_PID
1586 : TARGET_PID + current_cpu->thread_data[threadno].threadid;
1587 break;
1588
1589 case TARGET_SYS_getppid:
1590 /* Correct until CLONE_THREAD is implemented. */
1591 retval = current_cpu->thread_data == NULL
1592 ? TARGET_PID - 1
1593 : (TARGET_PID
1594 + current_cpu->thread_data[threadno].parent_threadid);
1595 break;
1596
1597 case TARGET_SYS_mmap2:
1598 {
1599 USI addr = arg1;
1600 USI len = arg2;
1601 USI prot = arg3;
1602 USI flags = arg4;
1603 USI fd = arg5;
1604 USI pgoff = arg6;
1605
1606 /* If the simulator wants to mmap more than the very large
1607 limit, something is wrong. FIXME: Return an error or
1608 abort? Have command-line selectable? */
1609 if (len > SIM_MAX_ALLOC_CHUNK)
1610 {
1611 retval = -cb_host_to_target_errno (cb, ENOMEM);
1612 break;
1613 }
1614
1615 if ((prot != (TARGET_PROT_READ | TARGET_PROT_WRITE)
1616 && (prot
1617 != (TARGET_PROT_READ
1618 | TARGET_PROT_WRITE
1619 | TARGET_PROT_EXEC))
1620 && prot != TARGET_PROT_READ)
1621 || (flags != (TARGET_MAP_ANONYMOUS | TARGET_MAP_PRIVATE)
1622 && flags != TARGET_MAP_PRIVATE
1623 && flags != TARGET_MAP_SHARED)
1624 || (fd != (USI) -1 && prot != TARGET_PROT_READ)
1625 || pgoff != 0)
1626 {
1627 retval
1628 = cris_unknown_syscall (current_cpu, pc,
1629 "Unimplemented mmap2 call "
1630 "(0x%lx, 0x%lx, 0x%lx, "
1631 "0x%lx, 0x%lx, 0x%lx)\n",
1632 (unsigned long) arg1,
1633 (unsigned long) arg2,
1634 (unsigned long) arg3,
1635 (unsigned long) arg4,
1636 (unsigned long) arg5,
1637 (unsigned long) arg6);
1638 break;
1639 }
1640 else if (fd != (USI) -1)
1641 {
1642 /* Map a file. */
1643
1644 USI newaddr;
1645 USI pos;
1646
1647 /* A non-aligned argument is allowed for files. */
1648 USI newlen = (len + 8191) & ~8191;
1649
1650 /* We only support read, which we should already have
1651 checked. Check again anyway. */
1652 if (prot != TARGET_PROT_READ)
1653 abort ();
1654
1655 newaddr
1656 = create_map (sd, &current_cpu->highest_mmapped_page, addr,
1657 newlen);
1658
1659 if (newaddr >= (USI) -8191)
1660 {
1661 abort ();
1662 retval = -cb_host_to_target_errno (cb, -(SI) newaddr);
1663 break;
1664 }
1665
1666 /* Find the current position in the file. */
1667 s.func = TARGET_SYS_lseek;
1668 s.arg1 = fd;
1669 s.arg2 = 0;
1670 s.arg3 = SEEK_CUR;
1671 if (cb_syscall (cb, &s) != CB_RC_OK)
1672 abort ();
1673 pos = s.result;
1674
1675 if (s.result < 0)
1676 abort ();
1677
1678 /* Use the standard read callback to read in "len"
1679 bytes. */
1680 s.func = TARGET_SYS_read;
1681 s.arg1 = fd;
1682 s.arg2 = newaddr;
1683 s.arg3 = len;
1684 if (cb_syscall (cb, &s) != CB_RC_OK)
1685 abort ();
1686
1687 if ((USI) s.result != len)
1688 abort ();
1689
1690 /* After reading, we need to go back to the previous
1691 position in the file. */
1692 s.func = TARGET_SYS_lseek;
1693 s.arg1 = fd;
1694 s.arg2 = pos;
1695 s.arg3 = SEEK_SET;
1696 if (cb_syscall (cb, &s) != CB_RC_OK)
1697 abort ();
1698 if (pos != (USI) s.result)
1699 abort ();
1700
1701 retval = newaddr;
1702 }
1703 else
1704 {
1705 USI newaddr
1706 = create_map (sd, &current_cpu->highest_mmapped_page, addr,
1707 (len + 8191) & ~8191);
1708
1709 if (newaddr >= (USI) -8191)
1710 retval = -cb_host_to_target_errno (cb, -(SI) newaddr);
1711 else
1712 retval = newaddr;
1713 }
1714 break;
1715 }
1716
1717 case TARGET_SYS_mprotect:
1718 {
1719 /* We only cover the case of linuxthreads mprotecting out its
1720 stack guard page. */
1721 USI addr = arg1;
1722 USI len = arg2;
1723 USI prot = arg3;
1724
1725 if ((addr & 8191) != 0
1726 || len != 8192
1727 || prot != TARGET_PROT_NONE
1728 || !is_mapped (sd, &current_cpu->highest_mmapped_page, addr,
1729 len))
1730 {
1731 retval
1732 = cris_unknown_syscall (current_cpu, pc,
1733 "Unimplemented mprotect call "
1734 "(0x%lx, 0x%lx, 0x%lx)\n",
1735 (unsigned long) arg1,
1736 (unsigned long) arg2,
1737 (unsigned long) arg3);
1738 break;
1739 }
1740
1741 /* FIXME: We should account for pages like this that are
1742 "mprotected out". For now, we just tell the simulator
1743 core to remove that page from its map. */
1744 sim_core_detach (sd, NULL, 0, 0, addr);
1745 retval = 0;
1746 break;
1747 }
1748
1749 case TARGET_SYS_ioctl:
1750 {
1751 /* We support only a very limited functionality: checking
1752 stdout with TCGETS to perform the isatty function. The
1753 TCGETS ioctl isn't actually performed or the result used by
1754 an isatty () caller in a "hello, world" program; only the
1755 return value is then used. Maybe we shouldn't care about
1756 the environment of the simulator regarding isatty, but
1757 that's been working before, in the xsim simulator. */
1758 if (arg2 == TARGET_TCGETS && arg1 == 1)
1759 retval = isatty (1) ? 0 : cb_host_to_target_errno (cb, EINVAL);
1760 else
1761 retval = -cb_host_to_target_errno (cb, EINVAL);
1762 break;
1763 }
1764
1765 case TARGET_SYS_munmap:
1766 {
1767 USI addr = arg1;
1768 USI len = arg2;
1769 USI result
1770 = unmap_pages (sd, &current_cpu->highest_mmapped_page, addr,
1771 len);
1772 retval = result != 0 ? -cb_host_to_target_errno (cb, result) : 0;
1773 break;
1774 }
1775
1776 case TARGET_SYS_wait4:
1777 {
1778 int i;
1779 USI pid = arg1;
1780 USI saddr = arg2;
1781 USI options = arg3;
1782 USI rusagep = arg4;
1783
1784 /* FIXME: We're not properly implementing __WCLONE, and we
1785 don't really need the special casing so we might as well
1786 make this general. */
1787 if ((!(pid == (USI) -1
1788 && options == (TARGET___WCLONE | TARGET_WNOHANG)
1789 && saddr != 0)
1790 && !(pid > 0
1791 && (options == TARGET___WCLONE
1792 || options == TARGET___WALL)))
1793 || rusagep != 0
1794 || current_cpu->thread_data == NULL)
1795 {
1796 retval
1797 = cris_unknown_syscall (current_cpu, pc,
1798 "Unimplemented wait4 call "
1799 "(0x%lx, 0x%lx, 0x%lx, 0x%lx)\n",
1800 (unsigned long) arg1,
1801 (unsigned long) arg2,
1802 (unsigned long) arg3,
1803 (unsigned long) arg4);
1804 break;
1805 }
1806
1807 if (pid == (USI) -1)
1808 for (i = 1; i < SIM_TARGET_MAX_THREADS; i++)
1809 {
1810 if (current_cpu->thread_data[threadno].threadid
1811 == current_cpu->thread_data[i].parent_threadid
1812 && current_cpu->thread_data[i].threadid != 0
1813 && current_cpu->thread_data[i].cpu_context == NULL)
1814 {
1815 /* A zombied child. Get the exit value and clear the
1816 zombied entry so it will be reused. */
1817 sim_core_write_unaligned_4 (current_cpu, pc, 0, saddr,
1818 current_cpu
1819 ->thread_data[i].exitval);
1820 retval
1821 = current_cpu->thread_data[i].threadid + TARGET_PID;
1822 memset (&current_cpu->thread_data[i], 0,
1823 sizeof (current_cpu->thread_data[i]));
1824 goto outer_break;
1825 }
1826 }
1827 else
1828 {
1829 /* We're waiting for a specific PID. If we don't find
1830 it zombied on this run, rerun the syscall. */
1831 for (i = 1; i < SIM_TARGET_MAX_THREADS; i++)
1832 if (pid == current_cpu->thread_data[i].threadid + TARGET_PID
1833 && current_cpu->thread_data[i].cpu_context == NULL)
1834 {
1835 if (saddr != 0)
1836 /* Get the exit value if the caller wants it. */
1837 sim_core_write_unaligned_4 (current_cpu, pc, 0,
1838 saddr,
1839 current_cpu
1840 ->thread_data[i]
1841 .exitval);
1842
1843 retval
1844 = current_cpu->thread_data[i].threadid + TARGET_PID;
1845 memset (&current_cpu->thread_data[i], 0,
1846 sizeof (current_cpu->thread_data[i]));
1847
1848 goto outer_break;
1849 }
1850
1851 sim_pc_set (current_cpu, pc);
1852 }
1853
1854 retval = -cb_host_to_target_errno (cb, ECHILD);
1855 outer_break:
1856 break;
1857 }
1858
1859 case TARGET_SYS_rt_sigaction:
1860 {
1861 USI signum = arg1;
1862 USI old_sa = arg3;
1863 USI new_sa = arg2;
1864
1865 /* The kernel says:
1866 struct sigaction {
1867 __sighandler_t sa_handler;
1868 unsigned long sa_flags;
1869 void (*sa_restorer)(void);
1870 sigset_t sa_mask;
1871 }; */
1872
1873 if (old_sa != 0)
1874 {
1875 sim_core_write_unaligned_4 (current_cpu, pc, 0, old_sa + 0,
1876 current_cpu->sighandler[signum]);
1877 sim_core_write_unaligned_4 (current_cpu, pc, 0, arg3 + 4, 0);
1878 sim_core_write_unaligned_4 (current_cpu, pc, 0, arg3 + 8, 0);
1879
1880 /* We'll assume _NSIG_WORDS is 2 for the kernel. */
1881 sim_core_write_unaligned_4 (current_cpu, pc, 0, arg3 + 12, 0);
1882 sim_core_write_unaligned_4 (current_cpu, pc, 0, arg3 + 16, 0);
1883 }
1884 if (new_sa != 0)
1885 {
1886 USI target_sa_handler
1887 = sim_core_read_unaligned_4 (current_cpu, pc, 0, new_sa);
1888 USI target_sa_flags
1889 = sim_core_read_unaligned_4 (current_cpu, pc, 0, new_sa + 4);
1890 USI target_sa_restorer
1891 = sim_core_read_unaligned_4 (current_cpu, pc, 0, new_sa + 8);
1892 USI target_sa_mask_low
1893 = sim_core_read_unaligned_4 (current_cpu, pc, 0, new_sa + 12);
1894 USI target_sa_mask_high
1895 = sim_core_read_unaligned_4 (current_cpu, pc, 0, new_sa + 16);
1896
1897 /* We won't interrupt a syscall so we won't restart it,
1898 but a signal(2) call ends up syscalling rt_sigaction
1899 with this flag, so we have to handle it. The
1900 sa_restorer field contains garbage when not
1901 TARGET_SA_RESTORER, so don't look at it. For the
1902 time being, we don't nest sighandlers, so we
1903 ignore the sa_mask, which simplifies things. */
1904 if ((target_sa_flags != 0
1905 && target_sa_flags != TARGET_SA_RESTART
1906 && target_sa_flags != (TARGET_SA_RESTART|TARGET_SA_SIGINFO))
1907 || target_sa_handler == 0)
1908 {
1909 retval
1910 = cris_unknown_syscall (current_cpu, pc,
1911 "Unimplemented rt_sigaction "
1912 "syscall "
1913 "(0x%lx, 0x%lx: "
1914 "[0x%x, 0x%x, 0x%x, "
1915 "{0x%x, 0x%x}], 0x%lx)\n",
1916 (unsigned long) arg1,
1917 (unsigned long) arg2,
1918 target_sa_handler,
1919 target_sa_flags,
1920 target_sa_restorer,
1921 target_sa_mask_low,
1922 target_sa_mask_high,
1923 (unsigned long) arg3);
1924 break;
1925 }
1926
1927 current_cpu->sighandler[signum] = target_sa_handler;
1928
1929 /* Because we may have unblocked signals, one may now be
1930 pending, if there are threads, that is. */
1931 if (current_cpu->thread_data)
1932 current_cpu->thread_data[threadno].sigpending = 1;
1933 }
1934 retval = 0;
1935 break;
1936 }
1937
1938 case TARGET_SYS_mremap:
1939 {
1940 USI addr = arg1;
1941 USI old_len = arg2;
1942 USI new_len = arg3;
1943 USI flags = arg4;
1944 USI new_addr = arg5;
1945 USI mapped_addr;
1946
1947 if (new_len == old_len)
1948 /* The program and/or library is possibly confused but
1949 this is a valid call. Happens with ipps-1.40 on file
1950 svs_all. */
1951 retval = addr;
1952 else if (new_len < old_len)
1953 {
1954 /* Shrinking is easy. */
1955 if (unmap_pages (sd, &current_cpu->highest_mmapped_page,
1956 addr + new_len, old_len - new_len) != 0)
1957 retval = -cb_host_to_target_errno (cb, EINVAL);
1958 else
1959 retval = addr;
1960 }
1961 else if (! is_mapped (sd, &current_cpu->highest_mmapped_page,
1962 addr + old_len, new_len - old_len))
1963 {
1964 /* If the extension isn't mapped, we can just add it. */
1965 mapped_addr
1966 = create_map (sd, &current_cpu->highest_mmapped_page,
1967 addr + old_len, new_len - old_len);
1968
1969 if (mapped_addr > (USI) -8192)
1970 retval = -cb_host_to_target_errno (cb, -(SI) mapped_addr);
1971 else
1972 retval = addr;
1973 }
1974 else if (flags & TARGET_MREMAP_MAYMOVE)
1975 {
1976 /* Create a whole new map and copy the contents
1977 block-by-block there. We ignore the new_addr argument
1978 for now. */
1979 char buf[8192];
1980 USI prev_addr = addr;
1981 USI prev_len = old_len;
1982
1983 mapped_addr
1984 = create_map (sd, &current_cpu->highest_mmapped_page,
1985 0, new_len);
1986
1987 if (mapped_addr > (USI) -8192)
1988 {
1989 retval = -cb_host_to_target_errno (cb, -(SI) new_addr);
1990 break;
1991 }
1992
1993 retval = mapped_addr;
1994
1995 for (; old_len > 0;
1996 old_len -= 8192, mapped_addr += 8192, addr += 8192)
1997 {
1998 if (sim_core_read_buffer (sd, current_cpu, read_map, buf,
1999 addr, 8192) != 8192
2000 || sim_core_write_buffer (sd, current_cpu, 0, buf,
2001 mapped_addr, 8192) != 8192)
2002 abort ();
2003 }
2004
2005 if (unmap_pages (sd, &current_cpu->highest_mmapped_page,
2006 prev_addr, prev_len) != 0)
2007 abort ();
2008 }
2009 else
2010 retval = -cb_host_to_target_errno (cb, -ENOMEM);
2011 break;
2012 }
2013
2014 case TARGET_SYS_poll:
2015 {
2016 int npollfds = arg2;
2017 int timeout = arg3;
2018 SI ufds = arg1;
2019 SI fd = -1;
2020 HI events = -1;
2021 HI revents = 0;
2022 struct stat buf;
2023 int i;
2024
2025 /* The kernel says:
2026 struct pollfd {
2027 int fd;
2028 short events;
2029 short revents;
2030 }; */
2031
2032 /* Check that this is the expected poll call from
2033 linuxthreads/manager.c; we don't support anything else.
2034 Remember, fd == 0 isn't supported. */
2035 if (npollfds != 1
2036 || ((fd = sim_core_read_unaligned_4 (current_cpu, pc,
2037 0, ufds)) <= 0)
2038 || ((events = sim_core_read_unaligned_2 (current_cpu, pc,
2039 0, ufds + 4))
2040 != TARGET_POLLIN)
2041 || ((cb->fstat) (cb, fd, &buf) != 0
2042 || (buf.st_mode & S_IFIFO) == 0)
2043 || current_cpu->thread_data == NULL)
2044 {
2045 retval
2046 = cris_unknown_syscall (current_cpu, pc,
2047 "Unimplemented poll syscall "
2048 "(0x%lx: [0x%x, 0x%x, x], "
2049 "0x%lx, 0x%lx)\n",
2050 (unsigned long) arg1, fd, events,
2051 (unsigned long) arg2,
2052 (unsigned long) arg3);
2053 break;
2054 }
2055
2056 retval = 0;
2057
2058 /* Iterate over threads; find a marker that a writer is
2059 sleeping, waiting for a reader. */
2060 for (i = 0; i < SIM_TARGET_MAX_THREADS; i++)
2061 if (current_cpu->thread_data[i].cpu_context != NULL
2062 && current_cpu->thread_data[i].pipe_read_fd == fd)
2063 {
2064 revents = TARGET_POLLIN;
2065 retval = 1;
2066 break;
2067 }
2068
2069 /* Timeout decreases with whatever time passed between the
2070 last syscall and this. That's not exactly right for the
2071 first call, but it's close enough that it isn't
2072 worthwhile to complicate matters by making that a special
2073 case. */
2074 timeout
2075 -= (TARGET_TIME_MS (current_cpu)
2076 - (current_cpu->thread_data[threadno].last_execution));
2077
2078 /* Arrange to repeat this syscall until timeout or event,
2079 decreasing timeout at each iteration. */
2080 if (timeout > 0 && revents == 0)
2081 {
2082 bfd_byte timeout_buf[4];
2083
2084 bfd_putl32 (timeout, timeout_buf);
2085 (*CPU_REG_STORE (current_cpu)) (current_cpu,
2086 H_GR_R12, timeout_buf, 4);
2087 sim_pc_set (current_cpu, pc);
2088 retval = arg1;
2089 break;
2090 }
2091
2092 sim_core_write_unaligned_2 (current_cpu, pc, 0, ufds + 4 + 2,
2093 revents);
2094 break;
2095 }
2096
2097 case TARGET_SYS_time:
2098 {
2099 retval = (int) (*cb->time) (cb, 0L);
2100
2101 /* At time of this writing, CB_SYSCALL_time doesn't do the
2102 part of setting *arg1 to the return value. */
2103 if (arg1)
2104 sim_core_write_unaligned_4 (current_cpu, pc, 0, arg1, retval);
2105 break;
2106 }
2107
2108 case TARGET_SYS_gettimeofday:
2109 if (arg1 != 0)
2110 {
2111 USI ts = TARGET_TIME (current_cpu);
2112 USI tms = TARGET_TIME_MS (current_cpu);
2113
2114 /* First dword is seconds since TARGET_EPOCH. */
2115 sim_core_write_unaligned_4 (current_cpu, pc, 0, arg1, ts);
2116
2117 /* Second dword is microseconds. */
2118 sim_core_write_unaligned_4 (current_cpu, pc, 0, arg1 + 4,
2119 (tms % 1000) * 1000);
2120 }
2121 if (arg2 != 0)
2122 {
2123 /* Time-zone info is always cleared. */
2124 sim_core_write_unaligned_4 (current_cpu, pc, 0, arg2, 0);
2125 sim_core_write_unaligned_4 (current_cpu, pc, 0, arg2 + 4, 0);
2126 }
2127 retval = 0;
2128 break;
2129
2130 case TARGET_SYS_llseek:
2131 {
2132 /* If it fits, tweak parameters to fit the "generic" 32-bit
2133 lseek and use that. */
2134 SI fd = arg1;
2135 SI offs_hi = arg2;
2136 SI offs_lo = arg3;
2137 SI resultp = arg4;
2138 SI whence = arg5;
2139 retval = 0;
2140
2141 if (!((offs_hi == 0 && offs_lo >= 0)
2142 || (offs_hi == -1 && offs_lo < 0)))
2143 {
2144 retval
2145 = cris_unknown_syscall (current_cpu, pc,
2146 "Unimplemented llseek offset,"
2147 " fd %d: 0x%x:0x%x\n",
2148 fd, (unsigned) arg2,
2149 (unsigned) arg3);
2150 break;
2151 }
2152
2153 s.func = TARGET_SYS_lseek;
2154 s.arg2 = offs_lo;
2155 s.arg3 = whence;
2156 if (cb_syscall (cb, &s) != CB_RC_OK)
2157 {
2158 sim_io_eprintf (sd, "Break 13: invalid %d? Returned %ld\n", callnum,
2159 s.result);
2160 sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped, SIM_SIGILL);
2161 }
2162 if (s.result < 0)
2163 retval = -s.errcode;
2164 else
2165 {
2166 sim_core_write_unaligned_4 (current_cpu, pc, 0, resultp,
2167 s.result);
2168 sim_core_write_unaligned_4 (current_cpu, pc, 0, resultp + 4,
2169 s.result < 0 ? -1 : 0);
2170 }
2171 break;
2172 }
2173
2174 /* This one does have a generic callback function, but at the time
2175 of this writing, cb_syscall does not have code for it, and we
2176 need target-specific code for the threads implementation
2177 anyway. */
2178 case TARGET_SYS_kill:
2179 {
2180 USI pid = arg1;
2181 USI sig = arg2;
2182
2183 retval = 0;
2184
2185 /* At kill(2), glibc sets signal masks such that the thread
2186 machinery is initialized. Still, there is and was only
2187 one thread. */
2188 if (current_cpu->max_threadid == 0)
2189 {
2190 if (pid != TARGET_PID)
2191 {
2192 retval = -cb_host_to_target_errno (cb, EPERM);
2193 break;
2194 }
2195
2196 /* FIXME: Signal infrastructure (target-to-sim mapping). */
2197 if (sig == TARGET_SIGABRT)
2198 /* A call "abort ()", i.e. "kill (getpid(), SIGABRT)" is
2199 the end-point for failing GCC test-cases. */
2200 sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped,
2201 SIM_SIGABRT);
2202 else
2203 {
2204 sim_io_eprintf (sd, "Unimplemented signal: %d\n", sig);
2205 sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped,
2206 SIM_SIGILL);
2207 }
2208
2209 /* This will not be reached. */
2210 abort ();
2211 }
2212 else
2213 retval = deliver_signal (current_cpu, sig, pid);
2214 break;
2215 }
2216
2217 case TARGET_SYS_rt_sigprocmask:
2218 {
2219 int i;
2220 USI how = arg1;
2221 USI newsetp = arg2;
2222 USI oldsetp = arg3;
2223
2224 if (how != TARGET_SIG_BLOCK
2225 && how != TARGET_SIG_SETMASK
2226 && how != TARGET_SIG_UNBLOCK)
2227 {
2228 retval
2229 = cris_unknown_syscall (current_cpu, pc,
2230 "Unimplemented rt_sigprocmask "
2231 "syscall (0x%x, 0x%x, 0x%x)\n",
2232 arg1, arg2, arg3);
2233 break;
2234 }
2235
2236 if (newsetp)
2237 {
2238 USI set_low
2239 = sim_core_read_unaligned_4 (current_cpu, pc, 0,
2240 newsetp);
2241 USI set_high
2242 = sim_core_read_unaligned_4 (current_cpu, pc, 0,
2243 newsetp + 4);
2244
2245 /* The sigmask is kept in the per-thread data, so we may
2246 need to create the first one. */
2247 if (current_cpu->thread_data == NULL)
2248 make_first_thread (current_cpu);
2249
2250 if (how == TARGET_SIG_SETMASK)
2251 for (i = 0; i < 64; i++)
2252 current_cpu->thread_data[threadno].sigdata[i].blocked = 0;
2253
2254 for (i = 0; i < 32; i++)
2255 if ((set_low & (1 << i)))
2256 current_cpu->thread_data[threadno].sigdata[i + 1].blocked
2257 = (how != TARGET_SIG_UNBLOCK);
2258
2259 for (i = 0; i < 31; i++)
2260 if ((set_high & (1 << i)))
2261 current_cpu->thread_data[threadno].sigdata[i + 33].blocked
2262 = (how != TARGET_SIG_UNBLOCK);
2263
2264 /* The mask changed, so a signal may be unblocked for
2265 execution. */
2266 current_cpu->thread_data[threadno].sigpending = 1;
2267 }
2268
2269 if (oldsetp != 0)
2270 {
2271 USI set_low = 0;
2272 USI set_high = 0;
2273
2274 for (i = 0; i < 32; i++)
2275 if (current_cpu->thread_data[threadno]
2276 .sigdata[i + 1].blocked)
2277 set_low |= 1 << i;
2278 for (i = 0; i < 31; i++)
2279 if (current_cpu->thread_data[threadno]
2280 .sigdata[i + 33].blocked)
2281 set_high |= 1 << i;
2282
2283 sim_core_write_unaligned_4 (current_cpu, pc, 0, oldsetp + 0, set_low);
2284 sim_core_write_unaligned_4 (current_cpu, pc, 0, oldsetp + 4, set_high);
2285 }
2286
2287 retval = 0;
2288 break;
2289 }
2290
2291 case TARGET_SYS_sigreturn:
2292 {
2293 int i;
2294 bfd_byte regbuf[4];
2295 int was_sigsuspended;
2296
2297 if (current_cpu->thread_data == NULL
2298 /* The CPU context is saved with the simulator data, not
2299 on the stack as in the real world. */
2300 || (current_cpu->thread_data[threadno].cpu_context_atsignal
2301 == NULL))
2302 {
2303 retval
2304 = cris_unknown_syscall (current_cpu, pc,
2305 "Invalid sigreturn syscall: "
2306 "no signal handler active "
2307 "(0x%lx, 0x%lx, 0x%lx, 0x%lx, "
2308 "0x%lx, 0x%lx)\n",
2309 (unsigned long) arg1,
2310 (unsigned long) arg2,
2311 (unsigned long) arg3,
2312 (unsigned long) arg4,
2313 (unsigned long) arg5,
2314 (unsigned long) arg6);
2315 break;
2316 }
2317
2318 was_sigsuspended
2319 = current_cpu->thread_data[threadno].sigsuspended;
2320
2321 /* Restore the sigmask, either from the stack copy made when
2322 the sighandler was called, or from the saved state
2323 specifically for sigsuspend(2). */
2324 if (was_sigsuspended)
2325 {
2326 current_cpu->thread_data[threadno].sigsuspended = 0;
2327 for (i = 0; i < 64; i++)
2328 current_cpu->thread_data[threadno].sigdata[i].blocked
2329 = current_cpu->thread_data[threadno]
2330 .sigdata[i].blocked_suspendsave;
2331 }
2332 else
2333 {
2334 USI sp;
2335 USI set_low;
2336 USI set_high;
2337
2338 (*CPU_REG_FETCH (current_cpu)) (current_cpu,
2339 H_GR_SP, regbuf, 4);
2340 sp = bfd_getl32 (regbuf);
2341 set_low
2342 = sim_core_read_unaligned_4 (current_cpu, pc, 0, sp);
2343 set_high
2344 = sim_core_read_unaligned_4 (current_cpu, pc, 0, sp + 4);
2345
2346 for (i = 0; i < 32; i++)
2347 current_cpu->thread_data[threadno].sigdata[i + 1].blocked
2348 = (set_low & (1 << i)) != 0;
2349 for (i = 0; i < 31; i++)
2350 current_cpu->thread_data[threadno].sigdata[i + 33].blocked
2351 = (set_high & (1 << i)) != 0;
2352 }
2353
2354 /* The mask changed, so a signal may be unblocked for
2355 execution. */
2356 current_cpu->thread_data[threadno].sigpending = 1;
2357
2358 memcpy (&current_cpu->cpu_data_placeholder,
2359 current_cpu->thread_data[threadno].cpu_context_atsignal,
2360 current_cpu->thread_cpu_data_size);
2361 free (current_cpu->thread_data[threadno].cpu_context_atsignal);
2362 current_cpu->thread_data[threadno].cpu_context_atsignal = NULL;
2363
2364 /* The return value must come from the saved R10. */
2365 (*CPU_REG_FETCH (current_cpu)) (current_cpu, H_GR_R10, regbuf, 4);
2366 retval = bfd_getl32 (regbuf);
2367
2368 /* We must also break the "sigsuspension loop". */
2369 if (was_sigsuspended)
2370 sim_pc_set (current_cpu, sim_pc_get (current_cpu) + 2);
2371 break;
2372 }
2373
2374 case TARGET_SYS_rt_sigsuspend:
2375 {
2376 USI newsetp = arg1;
2377 USI setsize = arg2;
2378
2379 if (setsize != 8)
2380 {
2381 retval
2382 = cris_unknown_syscall (current_cpu, pc,
2383 "Unimplemented rt_sigsuspend syscall"
2384 " arguments (0x%lx, 0x%lx)\n",
2385 (unsigned long) arg1,
2386 (unsigned long) arg2);
2387 break;
2388 }
2389
2390 /* Don't change the signal mask if we're already in
2391 sigsuspend state (i.e. this syscall is a rerun). */
2392 else if (!current_cpu->thread_data[threadno].sigsuspended)
2393 {
2394 USI set_low
2395 = sim_core_read_unaligned_4 (current_cpu, pc, 0,
2396 newsetp);
2397 USI set_high
2398 = sim_core_read_unaligned_4 (current_cpu, pc, 0,
2399 newsetp + 4);
2400 int i;
2401
2402 /* Save the current sigmask and insert the user-supplied
2403 one. */
2404 for (i = 0; i < 32; i++)
2405 {
2406 current_cpu->thread_data[threadno]
2407 .sigdata[i + 1].blocked_suspendsave
2408 = current_cpu->thread_data[threadno]
2409 .sigdata[i + 1].blocked;
2410
2411 current_cpu->thread_data[threadno]
2412 .sigdata[i + 1].blocked = (set_low & (1 << i)) != 0;
2413 }
2414 for (i = 0; i < 31; i++)
2415 {
2416 current_cpu->thread_data[threadno]
2417 .sigdata[i + 33].blocked_suspendsave
2418 = current_cpu->thread_data[threadno]
2419 .sigdata[i + 33].blocked;
2420 current_cpu->thread_data[threadno]
2421 .sigdata[i + 33].blocked = (set_high & (1 << i)) != 0;
2422 }
2423
2424 current_cpu->thread_data[threadno].sigsuspended = 1;
2425
2426 /* The mask changed, so a signal may be unblocked for
2427 execution. */
2428 current_cpu->thread_data[threadno].sigpending = 1;
2429 }
2430
2431 /* Because we don't use arg1 (newsetp) when this syscall is
2432 rerun, it doesn't matter that we overwrite it with the
2433 (constant) return value. */
2434 retval = -cb_host_to_target_errno (cb, EINTR);
2435 sim_pc_set (current_cpu, pc);
2436 break;
2437 }
2438
2439 /* Add case labels here for other syscalls using the 32-bit
2440 "struct stat", provided they have a corresponding simulator
2441 function of course. */
2442 case TARGET_SYS_stat:
2443 case TARGET_SYS_fstat:
2444 {
2445 /* As long as the infrastructure doesn't cache anything
2446 related to the stat mapping, this trick gets us a dual
2447 "struct stat"-type mapping in the least error-prone way. */
2448 const char *saved_map = cb->stat_map;
2449 CB_TARGET_DEFS_MAP *saved_syscall_map = cb->syscall_map;
2450
2451 cb->syscall_map = (CB_TARGET_DEFS_MAP *) syscall_stat32_map;
2452 cb->stat_map = stat32_map;
2453
2454 if (cb_syscall (cb, &s) != CB_RC_OK)
2455 {
2456 abort ();
2457 sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped,
2458 SIM_SIGILL);
2459 }
2460 retval = s.result == -1 ? -s.errcode : s.result;
2461
2462 cb->stat_map = saved_map;
2463 cb->syscall_map = saved_syscall_map;
2464 break;
2465 }
2466
2467 case TARGET_SYS_getcwd:
2468 {
2469 USI buf = arg1;
2470 USI size = arg2;
2471
2472 char *cwd = xmalloc (SIM_PATHMAX);
2473 if (cwd != getcwd (cwd, SIM_PATHMAX))
2474 abort ();
2475
2476 /* FIXME: When and if we support chdir, we need something
2477 a bit more elaborate. */
2478 if (simulator_sysroot[0] != '\0')
2479 strcpy (cwd, "/");
2480
2481 retval = -cb_host_to_target_errno (cb, ERANGE);
2482 if (strlen (cwd) + 1 <= size)
2483 {
2484 retval = strlen (cwd) + 1;
2485 if (sim_core_write_buffer (sd, current_cpu, 0, cwd,
2486 buf, retval)
2487 != (unsigned int) retval)
2488 retval = -cb_host_to_target_errno (cb, EFAULT);
2489 }
2490 free (cwd);
2491 break;
2492 }
2493
2494 case TARGET_SYS_readlink:
2495 {
2496 SI path = arg1;
2497 SI buf = arg2;
2498 SI bufsiz = arg3;
2499 char *pbuf = xmalloc (SIM_PATHMAX);
2500 char *lbuf = xmalloc (SIM_PATHMAX);
2501 char *lbuf_alloc = lbuf;
2502 int nchars = -1;
2503 int i;
2504 int o = 0;
2505
2506 if (sim_core_read_unaligned_1 (current_cpu, pc, 0, path) == '/')
2507 {
2508 strcpy (pbuf, simulator_sysroot);
2509 o += strlen (simulator_sysroot);
2510 }
2511
2512 for (i = 0; i + o < SIM_PATHMAX; i++)
2513 {
2514 pbuf[i + o]
2515 = sim_core_read_unaligned_1 (current_cpu, pc, 0, path + i);
2516 if (pbuf[i + o] == 0)
2517 break;
2518 }
2519
2520 if (i + o == SIM_PATHMAX)
2521 {
2522 retval = -cb_host_to_target_errno (cb, ENAMETOOLONG);
2523 break;
2524 }
2525
2526 /* Intervene calls for certain files expected in the target
2527 proc file system. */
2528 if (strcmp (pbuf + strlen (simulator_sysroot),
2529 "/proc/" XSTRING (TARGET_PID) "/exe") == 0)
2530 {
2531 char *argv0
2532 = (STATE_PROG_ARGV (sd) != NULL
2533 ? *STATE_PROG_ARGV (sd) : NULL);
2534
2535 if (argv0 == NULL || *argv0 == '.')
2536 {
2537 retval
2538 = cris_unknown_syscall (current_cpu, pc,
2539 "Unimplemented readlink syscall "
2540 "(0x%lx: [\"%s\"], 0x%lx)\n",
2541 (unsigned long) arg1, pbuf,
2542 (unsigned long) arg2);
2543 break;
2544 }
2545 else if (*argv0 == '/')
2546 {
2547 if (strncmp (simulator_sysroot, argv0,
2548 strlen (simulator_sysroot)) == 0)
2549 argv0 += strlen (simulator_sysroot);
2550
2551 strcpy (lbuf, argv0);
2552 nchars = strlen (argv0) + 1;
2553 }
2554 else
2555 {
2556 if (getcwd (lbuf, SIM_PATHMAX) != NULL
2557 && strlen (lbuf) + 2 + strlen (argv0) < SIM_PATHMAX)
2558 {
2559 if (strncmp (simulator_sysroot, lbuf,
2560 strlen (simulator_sysroot)) == 0)
2561 lbuf += strlen (simulator_sysroot);
2562
2563 strcat (lbuf, "/");
2564 strcat (lbuf, argv0);
2565 nchars = strlen (lbuf) + 1;
2566 }
2567 else
2568 abort ();
2569 }
2570 }
2571 else
2572 nchars = readlink (pbuf, lbuf, SIM_PATHMAX);
2573
2574 /* We trust that the readlink result returns a *relative*
2575 link, or one already adjusted for the file-path-prefix.
2576 (We can't generally tell the difference, so we go with
2577 the easiest decision; no adjustment.) */
2578
2579 if (nchars == -1)
2580 {
2581 retval = -cb_host_to_target_errno (cb, errno);
2582 break;
2583 }
2584
2585 if (bufsiz < nchars)
2586 nchars = bufsiz;
2587
2588 if (sim_core_write_buffer (sd, current_cpu, write_map, lbuf,
2589 buf, nchars) != (unsigned int) nchars)
2590 retval = -cb_host_to_target_errno (cb, EFAULT);
2591 else
2592 retval = nchars;
2593
2594 free (pbuf);
2595 free (lbuf_alloc);
2596 break;
2597 }
2598
2599 case TARGET_SYS_sched_getscheduler:
2600 {
2601 USI pid = arg1;
2602
2603 /* FIXME: Search (other) existing threads. */
2604 if (pid != 0 && pid != TARGET_PID)
2605 retval = -cb_host_to_target_errno (cb, ESRCH);
2606 else
2607 retval = TARGET_SCHED_OTHER;
2608 break;
2609 }
2610
2611 case TARGET_SYS_sched_getparam:
2612 {
2613 USI pid = arg1;
2614 USI paramp = arg2;
2615
2616 /* The kernel says:
2617 struct sched_param {
2618 int sched_priority;
2619 }; */
2620
2621 if (pid != 0 && pid != TARGET_PID)
2622 retval = -cb_host_to_target_errno (cb, ESRCH);
2623 else
2624 {
2625 /* FIXME: Save scheduler setting before threads are
2626 created too. */
2627 sim_core_write_unaligned_4 (current_cpu, pc, 0, paramp,
2628 current_cpu->thread_data != NULL
2629 ? (current_cpu
2630 ->thread_data[threadno]
2631 .priority)
2632 : 0);
2633 retval = 0;
2634 }
2635 break;
2636 }
2637
2638 case TARGET_SYS_sched_setparam:
2639 {
2640 USI pid = arg1;
2641 USI paramp = arg2;
2642
2643 if ((pid != 0 && pid != TARGET_PID)
2644 || sim_core_read_unaligned_4 (current_cpu, pc, 0,
2645 paramp) != 0)
2646 retval = -cb_host_to_target_errno (cb, EINVAL);
2647 else
2648 retval = 0;
2649 break;
2650 }
2651
2652 case TARGET_SYS_sched_setscheduler:
2653 {
2654 USI pid = arg1;
2655 USI policy = arg2;
2656 USI paramp = arg3;
2657
2658 if ((pid != 0 && pid != TARGET_PID)
2659 || policy != TARGET_SCHED_OTHER
2660 || sim_core_read_unaligned_4 (current_cpu, pc, 0,
2661 paramp) != 0)
2662 retval = -cb_host_to_target_errno (cb, EINVAL);
2663 else
2664 /* FIXME: Save scheduler setting to be read in later
2665 sched_getparam calls. */
2666 retval = 0;
2667 break;
2668 }
2669
2670 case TARGET_SYS_sched_yield:
2671 /* We reschedule to the next thread after a syscall anyway, so
2672 we don't have to do anything here than to set the return
2673 value. */
2674 retval = 0;
2675 break;
2676
2677 case TARGET_SYS_sched_get_priority_min:
2678 case TARGET_SYS_sched_get_priority_max:
2679 if (arg1 != 0)
2680 retval = -cb_host_to_target_errno (cb, EINVAL);
2681 else
2682 retval = 0;
2683 break;
2684
2685 case TARGET_SYS_ugetrlimit:
2686 {
2687 unsigned int curlim, maxlim;
2688 if (arg1 != TARGET_RLIMIT_STACK && arg1 != TARGET_RLIMIT_NOFILE)
2689 {
2690 retval = -cb_host_to_target_errno (cb, EINVAL);
2691 break;
2692 }
2693
2694 /* The kernel says:
2695 struct rlimit {
2696 unsigned long rlim_cur;
2697 unsigned long rlim_max;
2698 }; */
2699 if (arg1 == TARGET_RLIMIT_NOFILE)
2700 {
2701 /* Sadly a very low limit. Better not lie, though. */
2702 maxlim = curlim = MAX_CALLBACK_FDS;
2703 }
2704 else /* arg1 == TARGET_RLIMIT_STACK */
2705 {
2706 maxlim = 0xffffffff;
2707 curlim = 0x800000;
2708 }
2709 sim_core_write_unaligned_4 (current_cpu, pc, 0, arg2, curlim);
2710 sim_core_write_unaligned_4 (current_cpu, pc, 0, arg2 + 4, maxlim);
2711 retval = 0;
2712 break;
2713 }
2714
2715 case TARGET_SYS_setrlimit:
2716 if (arg1 != TARGET_RLIMIT_STACK)
2717 {
2718 retval = -cb_host_to_target_errno (cb, EINVAL);
2719 break;
2720 }
2721 /* FIXME: Save values for future ugetrlimit calls. */
2722 retval = 0;
2723 break;
2724
2725 /* Provide a very limited subset of the sysctl functions, and
2726 abort for the rest. */
2727 case TARGET_SYS__sysctl:
2728 {
2729 /* The kernel says:
2730 struct __sysctl_args {
2731 int *name;
2732 int nlen;
2733 void *oldval;
2734 size_t *oldlenp;
2735 void *newval;
2736 size_t newlen;
2737 unsigned long __unused[4];
2738 }; */
2739 SI name = sim_core_read_unaligned_4 (current_cpu, pc, 0, arg1);
2740 SI name0 = name == 0
2741 ? 0 : sim_core_read_unaligned_4 (current_cpu, pc, 0, name);
2742 SI name1 = name == 0
2743 ? 0 : sim_core_read_unaligned_4 (current_cpu, pc, 0, name + 4);
2744 SI nlen
2745 = sim_core_read_unaligned_4 (current_cpu, pc, 0, arg1 + 4);
2746 SI oldval
2747 = sim_core_read_unaligned_4 (current_cpu, pc, 0, arg1 + 8);
2748 SI oldlenp
2749 = sim_core_read_unaligned_4 (current_cpu, pc, 0, arg1 + 12);
2750 SI oldlen = oldlenp == 0
2751 ? 0 : sim_core_read_unaligned_4 (current_cpu, pc, 0, oldlenp);
2752 SI newval
2753 = sim_core_read_unaligned_4 (current_cpu, pc, 0, arg1 + 16);
2754 SI newlen
2755 = sim_core_read_unaligned_4 (current_cpu, pc, 0, arg1 + 20);
2756
2757 if (name0 == TARGET_CTL_KERN && name1 == TARGET_CTL_KERN_VERSION)
2758 {
2759 SI to_write = oldlen < (SI) sizeof (TARGET_UTSNAME)
2760 ? oldlen : (SI) sizeof (TARGET_UTSNAME);
2761
2762 sim_core_write_unaligned_4 (current_cpu, pc, 0, oldlenp,
2763 sizeof (TARGET_UTSNAME));
2764
2765 if (sim_core_write_buffer (sd, current_cpu, write_map,
2766 TARGET_UTSNAME, oldval,
2767 to_write)
2768 != (unsigned int) to_write)
2769 retval = -cb_host_to_target_errno (cb, EFAULT);
2770 else
2771 retval = 0;
2772 break;
2773 }
2774
2775 retval
2776 = cris_unknown_syscall (current_cpu, pc,
2777 "Unimplemented _sysctl syscall "
2778 "(0x%lx: [0x%lx, 0x%lx],"
2779 " 0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx)\n",
2780 (unsigned long) name,
2781 (unsigned long) name0,
2782 (unsigned long) name1,
2783 (unsigned long) nlen,
2784 (unsigned long) oldval,
2785 (unsigned long) oldlenp,
2786 (unsigned long) newval,
2787 (unsigned long) newlen);
2788 break;
2789 }
2790
2791 case TARGET_SYS_exit:
2792 {
2793 /* Here for all but the last thread. */
2794 int i;
2795 int pid
2796 = current_cpu->thread_data[threadno].threadid + TARGET_PID;
2797 int ppid
2798 = (current_cpu->thread_data[threadno].parent_threadid
2799 + TARGET_PID);
2800 int exitsig = current_cpu->thread_data[threadno].exitsig;
2801
2802 /* Any children are now all orphans. */
2803 for (i = 0; i < SIM_TARGET_MAX_THREADS; i++)
2804 if (current_cpu->thread_data[i].parent_threadid
2805 == current_cpu->thread_data[threadno].threadid)
2806 /* Make getppid(2) return 1 for them, poor little ones. */
2807 current_cpu->thread_data[i].parent_threadid = -TARGET_PID + 1;
2808
2809 /* Free the cpu context data. When the parent has received
2810 the exit status, we'll clear the entry too. */
2811 free (current_cpu->thread_data[threadno].cpu_context);
2812 current_cpu->thread_data[threadno].cpu_context = NULL;
2813 current_cpu->m1threads--;
2814 if (arg1 != 0)
2815 {
2816 sim_io_eprintf (sd, "Thread %d exited with status %d\n",
2817 pid, arg1);
2818 sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped,
2819 SIM_SIGILL);
2820 }
2821
2822 /* Still, we may want to support non-zero exit values. */
2823 current_cpu->thread_data[threadno].exitval = arg1 << 8;
2824
2825 if (exitsig)
2826 deliver_signal (current_cpu, exitsig, ppid);
2827 break;
2828 }
2829
2830 case TARGET_SYS_clone:
2831 {
2832 int nthreads = current_cpu->m1threads + 1;
2833 void *thread_cpu_data;
2834 bfd_byte old_sp_buf[4];
2835 bfd_byte sp_buf[4];
2836 const bfd_byte zeros[4] = { 0, 0, 0, 0 };
2837 int i;
2838
2839 /* That's right, the syscall clone arguments are reversed
2840 compared to sys_clone notes in clone(2) and compared to
2841 other Linux ports (i.e. it's the same order as in the
2842 clone(2) libcall). */
2843 USI flags = arg2;
2844 USI newsp = arg1;
2845
2846 if (nthreads == SIM_TARGET_MAX_THREADS)
2847 {
2848 retval = -cb_host_to_target_errno (cb, EAGAIN);
2849 break;
2850 }
2851
2852 /* FIXME: Implement the low byte. */
2853 if ((flags & ~TARGET_CSIGNAL) !=
2854 (TARGET_CLONE_VM
2855 | TARGET_CLONE_FS
2856 | TARGET_CLONE_FILES
2857 | TARGET_CLONE_SIGHAND)
2858 || newsp == 0)
2859 {
2860 retval
2861 = cris_unknown_syscall (current_cpu, pc,
2862 "Unimplemented clone syscall "
2863 "(0x%lx, 0x%lx)\n",
2864 (unsigned long) arg1,
2865 (unsigned long) arg2);
2866 break;
2867 }
2868
2869 if (current_cpu->thread_data == NULL)
2870 make_first_thread (current_cpu);
2871
2872 /* The created thread will get the new SP and a cleared R10.
2873 Since it's created out of a copy of the old thread and we
2874 don't have a set-register-function that just take the
2875 cpu_data as a parameter, we set the childs values first,
2876 and write back or overwrite them in the parent after the
2877 copy. */
2878 (*CPU_REG_FETCH (current_cpu)) (current_cpu,
2879 H_GR_SP, old_sp_buf, 4);
2880 bfd_putl32 (newsp, sp_buf);
2881 (*CPU_REG_STORE (current_cpu)) (current_cpu,
2882 H_GR_SP, sp_buf, 4);
2883 (*CPU_REG_STORE (current_cpu)) (current_cpu,
2884 H_GR_R10, (bfd_byte *) zeros, 4);
2885 thread_cpu_data
2886 = (*current_cpu
2887 ->make_thread_cpu_data) (current_cpu,
2888 &current_cpu->cpu_data_placeholder);
2889 (*CPU_REG_STORE (current_cpu)) (current_cpu,
2890 H_GR_SP, old_sp_buf, 4);
2891
2892 retval = ++current_cpu->max_threadid + TARGET_PID;
2893
2894 /* Find an unused slot. After a few threads have been created
2895 and exited, the array is expected to be a bit fragmented.
2896 We don't reuse the first entry, though, that of the
2897 original thread. */
2898 for (i = 1; i < SIM_TARGET_MAX_THREADS; i++)
2899 if (current_cpu->thread_data[i].cpu_context == NULL
2900 /* Don't reuse a zombied entry. */
2901 && current_cpu->thread_data[i].threadid == 0)
2902 break;
2903
2904 memcpy (&current_cpu->thread_data[i],
2905 &current_cpu->thread_data[threadno],
2906 sizeof (current_cpu->thread_data[i]));
2907 current_cpu->thread_data[i].cpu_context = thread_cpu_data;
2908 current_cpu->thread_data[i].cpu_context_atsignal = NULL;
2909 current_cpu->thread_data[i].threadid = current_cpu->max_threadid;
2910 current_cpu->thread_data[i].parent_threadid
2911 = current_cpu->thread_data[threadno].threadid;
2912 current_cpu->thread_data[i].pipe_read_fd = 0;
2913 current_cpu->thread_data[i].pipe_write_fd = 0;
2914 current_cpu->thread_data[i].at_syscall = 0;
2915 current_cpu->thread_data[i].sigpending = 0;
2916 current_cpu->thread_data[i].sigsuspended = 0;
2917 current_cpu->thread_data[i].exitsig = flags & TARGET_CSIGNAL;
2918 current_cpu->m1threads = nthreads;
2919 break;
2920 }
2921
2922 /* Better watch these in case they do something necessary. */
2923 case TARGET_SYS_socketcall:
2924 retval = -cb_host_to_target_errno (cb, ENOSYS);
2925 break;
2926
2927 unimplemented_syscall:
2928 default:
2929 retval
2930 = cris_unknown_syscall (current_cpu, pc,
2931 "Unimplemented syscall: %d "
2932 "(0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x)\n",
2933 callnum, arg1, arg2, arg3, arg4, arg5,
2934 arg6);
2935 }
2936 }
2937
2938 /* Minimal support for fcntl F_GETFL as used in open+fdopen. */
2939 if (callnum == TARGET_SYS_open)
2940 {
2941 current_cpu->last_open_fd = retval;
2942 current_cpu->last_open_flags = arg2;
2943 }
2944
2945 current_cpu->last_syscall = callnum;
2946
2947 /* A system call is a rescheduling point. For the time being, we don't
2948 reschedule anywhere else. */
2949 if (current_cpu->m1threads != 0
2950 /* We need to schedule off from an exiting thread that is the
2951 second-last one. */
2952 || (current_cpu->thread_data != NULL
2953 && current_cpu->thread_data[threadno].cpu_context == NULL))
2954 {
2955 bfd_byte retval_buf[4];
2956
2957 current_cpu->thread_data[threadno].last_execution
2958 = TARGET_TIME_MS (current_cpu);
2959 bfd_putl32 (retval, retval_buf);
2960 (*CPU_REG_STORE (current_cpu)) (current_cpu, H_GR_R10, retval_buf, 4);
2961
2962 current_cpu->thread_data[threadno].at_syscall = 1;
2963 reschedule (current_cpu);
2964
2965 (*CPU_REG_FETCH (current_cpu)) (current_cpu, H_GR_R10, retval_buf, 4);
2966 retval = bfd_getl32 (retval_buf);
2967 }
2968
2969 return retval;
2970 }
2971
2972 /* Callback from simulator write saying that the pipe at (reader, writer)
2973 is now non-empty (so the writer should wait until the pipe is empty, at
2974 least not write to this or any other pipe). Simplest is to just wait
2975 until the pipe is empty. */
2976
2977 static void
2978 cris_pipe_nonempty (host_callback *cb ATTRIBUTE_UNUSED,
2979 int reader, int writer)
2980 {
2981 SIM_CPU *cpu = current_cpu_for_cb_callback;
2982 const bfd_byte zeros[4] = { 0, 0, 0, 0 };
2983
2984 /* It's the current thread: we just have to re-run the current
2985 syscall instruction (presumably "break 13") and change the syscall
2986 to the special simulator-wait code. Oh, and set a marker that
2987 we're waiting, so we can disambiguate the special call from a
2988 program error.
2989
2990 This function may be called multiple times between cris_pipe_empty,
2991 but we must avoid e.g. decreasing PC every time. Check fd markers
2992 to tell. */
2993 if (cpu->thread_data == NULL)
2994 {
2995 sim_io_eprintf (CPU_STATE (cpu),
2996 "Terminating simulation due to writing pipe rd:wr %d:%d"
2997 " from one single thread\n", reader, writer);
2998 sim_engine_halt (CPU_STATE (cpu), cpu,
2999 NULL, sim_pc_get (cpu), sim_stopped, SIM_SIGILL);
3000 }
3001 else if (cpu->thread_data[cpu->threadno].pipe_write_fd == 0)
3002 {
3003 cpu->thread_data[cpu->threadno].pipe_write_fd = writer;
3004 cpu->thread_data[cpu->threadno].pipe_read_fd = reader;
3005 /* FIXME: We really shouldn't change registers other than R10 in
3006 syscalls (like R9), here or elsewhere. */
3007 (*CPU_REG_STORE (cpu)) (cpu, H_GR_R9, (bfd_byte *) zeros, 4);
3008 sim_pc_set (cpu, sim_pc_get (cpu) - 2);
3009 }
3010 }
3011
3012 /* Callback from simulator close or read call saying that the pipe at
3013 (reader, writer) is now empty (so the writer can write again, perhaps
3014 leave a waiting state). If there are bytes remaining, they couldn't be
3015 consumed (perhaps due to the pipe closing). */
3016
3017 static void
3018 cris_pipe_empty (host_callback *cb,
3019 int reader,
3020 int writer)
3021 {
3022 int i;
3023 SIM_CPU *cpu = current_cpu_for_cb_callback;
3024 bfd_byte r10_buf[4];
3025 int remaining
3026 = cb->pipe_buffer[writer].size - cb->pipe_buffer[reader].size;
3027
3028 /* We need to find the thread that waits for this pipe. */
3029 for (i = 0; i < SIM_TARGET_MAX_THREADS; i++)
3030 if (cpu->thread_data[i].cpu_context
3031 && cpu->thread_data[i].pipe_write_fd == writer)
3032 {
3033 int retval;
3034
3035 /* Temporarily switch to this cpu context, so we can change the
3036 PC by ordinary calls. */
3037
3038 memcpy (cpu->thread_data[cpu->threadno].cpu_context,
3039 &cpu->cpu_data_placeholder,
3040 cpu->thread_cpu_data_size);
3041 memcpy (&cpu->cpu_data_placeholder,
3042 cpu->thread_data[i].cpu_context,
3043 cpu->thread_cpu_data_size);
3044
3045 /* The return value is supposed to contain the number of
3046 written bytes, which is the number of bytes requested and
3047 returned at the write call. You might think the right
3048 thing is to adjust the return-value to be only the
3049 *consumed* number of bytes, but it isn't. We're only
3050 called if the pipe buffer is fully consumed or it is being
3051 closed, possibly with remaining bytes. For the latter
3052 case, the writer is still supposed to see success for
3053 PIPE_BUF bytes (a constant which we happen to know and is
3054 unlikely to change). The return value may also be a
3055 negative number; an error value. This case is covered
3056 because "remaining" is always >= 0. */
3057 (*CPU_REG_FETCH (cpu)) (cpu, H_GR_R10, r10_buf, 4);
3058 retval = (int) bfd_getl_signed_32 (r10_buf);
3059 if (retval - remaining > TARGET_PIPE_BUF)
3060 {
3061 bfd_putl32 (retval - remaining, r10_buf);
3062 (*CPU_REG_STORE (cpu)) (cpu, H_GR_R10, r10_buf, 4);
3063 }
3064 sim_pc_set (cpu, sim_pc_get (cpu) + 2);
3065 memcpy (cpu->thread_data[i].cpu_context,
3066 &cpu->cpu_data_placeholder,
3067 cpu->thread_cpu_data_size);
3068 memcpy (&cpu->cpu_data_placeholder,
3069 cpu->thread_data[cpu->threadno].cpu_context,
3070 cpu->thread_cpu_data_size);
3071 cpu->thread_data[i].pipe_read_fd = 0;
3072 cpu->thread_data[i].pipe_write_fd = 0;
3073 return;
3074 }
3075
3076 abort ();
3077 }
3078
3079 /* We have a simulator-specific notion of time. See TARGET_TIME. */
3080
3081 static long
3082 cris_time (host_callback *cb ATTRIBUTE_UNUSED, long *t)
3083 {
3084 long retval = TARGET_TIME (current_cpu_for_cb_callback);
3085 if (t)
3086 *t = retval;
3087 return retval;
3088 }
3089
3090 /* Set target-specific callback data. */
3091
3092 void
3093 cris_set_callbacks (host_callback *cb)
3094 {
3095 /* Yeargh, have to cast away constness to avoid warnings. */
3096 cb->syscall_map = (CB_TARGET_DEFS_MAP *) syscall_map;
3097 cb->errno_map = (CB_TARGET_DEFS_MAP *) errno_map;
3098
3099 /* The kernel stat64 layout. If we see a file > 2G, the "long"
3100 parameter to cb_store_target_endian will make st_size negative.
3101 Similarly for st_ino. FIXME: Find a 64-bit type, and use it
3102 *unsigned*, and/or add syntax for signed-ness. */
3103 cb->stat_map = stat_map;
3104 cb->open_map = (CB_TARGET_DEFS_MAP *) open_map;
3105 cb->pipe_nonempty = cris_pipe_nonempty;
3106 cb->pipe_empty = cris_pipe_empty;
3107 cb->time = cris_time;
3108 }
3109
3110 /* Process an address exception. */
3111
3112 void
3113 cris_core_signal (SIM_DESC sd, SIM_CPU *current_cpu, sim_cia cia,
3114 unsigned int map, int nr_bytes, address_word addr,
3115 transfer_type transfer, sim_core_signals sig)
3116 {
3117 sim_core_signal (sd, current_cpu, cia, map, nr_bytes, addr,
3118 transfer, sig);
3119 }