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