sim/cris/traps.c

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