sim/cris/traps.c

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