sim/cris/traps.c

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