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